startapp 0.1.6

data/lib/rhc/rest/user.rb

@@ -0,0 +1,32 @@
+require 'ostruct'
+
+module RHC
+  module Rest
+    class User < Base
+      define_attr :id, :login, :plan_id, :max_gears, :consumed_gears, :max_domains
+
+      def add_key(name, content, type)
+        debug "Add key #{name} of type #{type} for user #{login}"
+        rest_method "ADD_KEY", :name => name, :type => type, :content => content
+      end
+
+      def keys
+        debug "Getting all keys for user #{login}"
+        rest_method "LIST_KEYS"
+      end
+
+      #Find Key by name
+      def find_key(name)
+        keys.detect { |key| key.name == name }
+      end
+
+      def max_domains
+        attributes['max_domains'] || 1
+      end
+
+      def capabilities
+        @capabilities ||= OpenStruct.new attribute('capabilities')
+      end
+    end
+  end
+end

data/lib/rhc/rest.rb

@@ -0,0 +1,148 @@
+module RHC
+  module Rest
+
+    autoload :Base,                 'rhc/rest/base'
+    autoload :Attributes,           'rhc/rest/attributes'
+
+    autoload :HTTPClient,           'rhc/rest/httpclient'
+
+    autoload :Alias,                'rhc/rest/alias'
+    autoload :Api,                  'rhc/rest/api'
+    autoload :Application,          'rhc/rest/application'
+    autoload :Authorization,        'rhc/rest/authorization'
+    autoload :Cartridge,            'rhc/rest/cartridge'
+    autoload :Client,               'rhc/rest/client'
+    autoload :Deployment,           'rhc/rest/deployment'
+    autoload :Domain,               'rhc/rest/domain'
+    autoload :EnvironmentVariable,  'rhc/rest/environment_variable'
+    autoload :GearGroup,            'rhc/rest/gear_group'
+    autoload :Key,                  'rhc/rest/key'
+    autoload :Membership,           'rhc/rest/membership'
+    autoload :User,                 'rhc/rest/user'
+
+    class Exception < RuntimeError
+      attr_reader :code
+      def initialize(message=nil, code=1)
+        super(message)
+        @code = (Integer(code) rescue nil)
+      end
+    end
+
+    #Exceptions thrown in case of an HTTP 5xx is received.
+    class ServerErrorException < Exception; end
+
+    #Exceptions thrown in case of an HTTP 503 is received.
+    #
+    #503 Service Unavailable
+    #
+    #The server is currently unable to handle the request due to a temporary
+    #overloading or maintenance of the server. The implication is that this
+    #is a temporary condition which will be alleviated after some delay.
+    class ServiceUnavailableException < ServerErrorException; end
+
+    #Exceptions thrown in case of an HTTP 4xx is received with the exception
+    #of 401, 403, 403 and 422 where a more sepcific exception is thrown
+    #
+    #HTTP Error Codes 4xx
+    #
+    #The 4xx class of status code is intended for cases in which the client
+    #seems to have errored.
+    class ClientErrorException < Exception; end
+
+    #Exceptions thrown in case of an HTTP 404 is received.
+    #
+    #404 Not Found
+    #
+    #The server has not found anything matching the Request-URI or the
+    #requested resource does not exist
+    class ResourceNotFoundException < ClientErrorException; end
+    class ApiEndpointNotFound < ResourceNotFoundException; end
+
+    # 404 errors for specific resource types
+    class DomainNotFoundException < ResourceNotFoundException
+      def initialize(msg)
+        super(msg,127)
+      end
+    end
+    class ApplicationNotFoundException < ResourceNotFoundException
+      def initialize(msg)
+        super(msg,101)
+      end
+    end
+
+    #Exceptions thrown in case of an HTTP 422 is received.
+    class ValidationException < ClientErrorException
+      attr_reader :field
+      def initialize(message, field=nil, error_code=1)
+        super(message, error_code)
+        @field = field
+      end
+    end
+
+    #Exceptions thrown in case of an HTTP 403 is received.
+    #
+    #403 Forbidden
+    #
+    #The server understood the request, but is refusing to fulfill it.
+    #Authorization will not help and the request SHOULD NOT be repeated.
+    class RequestDeniedException < ClientErrorException; end
+
+    #Exceptions thrown in case of an HTTP 401 is received.
+    #
+    #401 Unauthorized
+    #
+    #The request requires user authentication.  If the request already
+    #included Authorization credentials, then the 401 response indicates
+    #that authorization has been refused for those credentials.
+    class UnAuthorizedException < ClientErrorException; end
+    class TokenExpiredOrInvalid < UnAuthorizedException; end
+
+    # DEPRECATED Unreachable host, SSL Exception
+    class ResourceAccessException < Exception; end
+
+    #I/O Exceptions Connection timeouts, etc
+    class ConnectionException < Exception; end
+    class TimeoutException < ConnectionException
+      def initialize(message, nested=nil)
+        super(message)
+        @nested = nested
+      end
+
+      def on_receive?
+        @nested.is_a? HTTPClient::ReceiveTimeoutError
+      end
+      def on_connect?
+        @nested.is_a? HTTPClient::ConnectTimeoutError
+      end
+      def on_send?
+        @nested.is_a? HTTPClient::SendTimeoutError
+      end
+    end
+
+    class SSLConnectionFailed < ConnectionException
+      attr_reader :reason
+      def initialize(reason, message)
+        super message
+        @reason = reason
+      end
+    end
+    class CertificateVerificationFailed < SSLConnectionFailed; end
+    class SelfSignedCertificate < CertificateVerificationFailed; end
+
+    class SSLVersionRejected < SSLConnectionFailed; end
+
+    class MultipleCartridgeCreationNotSupported < Exception; end
+
+    class DownloadingCartridgesNotSupported < Exception; end
+
+    class InitialGitUrlNotSupported < Exception; end
+
+    class SslCertificatesNotSupported < Exception; end
+
+    class AuthorizationsNotSupported < Exception
+      def initialize(message="The server does not support setting, retrieving, or authenticating with authorization tokens.")
+        super(message, 1)
+      end
+    end
+  end
+end

data/lib/rhc/scp_helpers.rb

@@ -0,0 +1,27 @@
+###
+# ssh_key_helpers.rb - methods to help manipulate ssh keys
+#
+# Copyright 2012 Red Hat, Inc. and/or its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+#  limitations under the License.
+
+require 'net/ssh'
+require 'net/scp'
+require 'rhc/ssh_helpers'
+require 'rhc/vendor/sshkey'
+
+module RHC
+  module SCPHelpers
+    include SSHHelpers
+  end
+end

data/lib/rhc/ssh_helpers.rb

@@ -0,0 +1,380 @@
+###
+# ssh_key_helpers.rb - methods to help manipulate ssh keys
+#
+# Copyright 2012 Red Hat, Inc. and/or its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+#  limitations under the License.
+
+require 'net/ssh'
+require 'rhc/vendor/sshkey'
+require 'httpclient'
+
+module RHC
+  module SSHHelpers
+
+    class MultipleGearTask
+      def initialize(command, over, opts={})
+        requires_ssh_multi!
+
+        @command = command
+        @over = over
+        @opts = opts
+      end
+
+      def run(&block)
+        out = nil
+
+        Net::SSH::Multi.start(
+          :concurrent_connections => @opts[:limit],
+          :on_error => lambda{ |server| $stderr.puts RHC::Helpers.color("Unable to connect to gear #{server}", :red) }
+        ) do |session|
+
+          @over.each do |item|
+            case item
+            when RHC::Rest::GearGroup
+              item.gears.each do |gear|
+                session.use ssh_host_for(gear), :properties => {:gear => gear, :group => item}
+              end
+            #when RHC::Rest::Gear
+            #  session.use ssh_host_for(item), :properties => {:gear => item}
+            #end
+            else
+              raise "Cannot establish an SSH session to this type"
+            end
+          end
+          session.exec @command, &(
+            case
+            when @opts[:raw]
+              lambda { |ch, dest, data|
+                (dest == :stdout ? $stdout : $stderr).puts data
+              }
+            when @opts[:as] == :table
+              out = []
+              lambda { |ch, dest, data|
+                label = label_for(ch)
+                data.chomp.each_line do |line|
+                  row = out.find{ |row| row[0] == label } || (out << [label, []])[-1]
+                  row[1] << line
+                end
+              }
+            when @opts[:as] == :gear
+              lambda { |ch, dest, data| (ch.connection.properties[:gear]['data'] ||= "") << data }
+            else
+              width = 0
+              lambda { |ch, dest, data|
+                label = label_for(ch)
+                io = dest == :stdout ? $stdout : $stderr
+                data.chomp!
+
+                if data.each_line.to_a.count < 2
+                  io.puts "[#{label}] #{data}"
+                elsif @opts[:always_prefix]
+                  data.each_line do |line|
+                    io.puts "[#{label}] #{line}"
+                  end
+                else
+                  io.puts "=== #{label}"
+                  io.puts data
+                end
+              }
+            end)
+          session.loop
+        end
+
+        if block_given? && !@opts[:raw]
+          case
+          when @opts[:as] == :gear
+            out = []
+            @over.each do |item|
+              case item
+              when RHC::Rest::GearGroup then item.gears.each{ |gear| out << yield(gear, gear['data'], item) }
+              #when RHC::Rest::Gear      then out << yield(gear, gear['data'], nil)
+              end
+            end
+          end
+        end
+
+        out
+      end
+      protected
+        def ssh_host_for(gear)
+          RHC::Helpers.ssh_string(gear['ssh_url']) or raise NoPerGearOperations
+        end
+
+        def label_for(channel)
+          channel.properties[:label] ||=
+            begin
+              group = channel.connection.properties[:group]
+              "#{key_for(channel)} #{group.cartridges.map{ |c| c['name'] }.join('+')}"
+            end
+        end
+
+        def key_for(channel)
+          channel.connection.properties[:gear]['id']
+        end
+
+        def requires_ssh_multi!
+          begin
+            require 'net/ssh/multi'
+          rescue LoadError
+            raise RHC::OperationNotSupportedException, "You must install Net::SSH::Multi to use the --gears option.  Most systems: 'gem install net-ssh-multi'"
+          end
+        end
+    end
+
+    def run_on_gears(command, gears, opts={}, &block)
+      debug "Executing #{command} on each of #{gears.inspect}"
+      MultipleGearTask.new(command, gears, {:limit => options.limit, :always_prefix => options.always_prefix, :raw => options.raw}.merge(opts)).run(&block)
+    end
+
+    def table_from_gears(command, groups, opts={}, &block)
+      cells = run_on_gears(command, groups, {:as => :table}.merge(opts), &block)
+      cells.each{ |r| r.concat(r.pop.first.split(opts[:split_cells_on])) } if !block_given? && opts[:split_cells_on]
+      say table cells, opts unless options.raw
+    end
+
+    def ssh_command_for_op(operation)
+      #case operation
+      raise RHC::OperationNotSupportedException, "The operation #{operation} is not supported."
+      #end
+    end
+
+    # Public: Run ssh command on remote host
+    #
+    # host - The String of the remote hostname to ssh to.
+    # username - The String username of the remote user to ssh as.
+    # command - The String command to run on the remote host.
+    # compression - Use compression in ssh, set to false if sending files.
+    # request_pty - Request for pty, set to false when pipe a file.
+    # block - Will yield this block and send the channel if provided.
+    #
+    # Examples
+    #
+    #  ssh_ruby('myapp-t.rhcloud.com',
+    #            '109745632b514e9590aa802ec015b074',
+    #            'rhcsh tail -f $OPENSHIFT_LOG_DIR/*"')
+    #  # => true
+    #
+    # Returns true on success
+    def ssh_ruby(host, username, command, compression=false, request_pty=false, &block)
+      debug "Opening Net::SSH connection to #{host}, #{username}, #{command}"
+      exit_status = 0
+      options = {:compression => compression}
+      options[:verbose] = :debug if debug?
+      Net::SSH.start(host, username, options) do |session|
+        #:nocov:
+        channel = session.open_channel do |channel|
+          if request_pty
+            channel.request_pty do |ch, success|
+              say "pty could not be obtained" unless success
+            end
+          end
+          channel.exec(command) do |ch, success|
+            channel.on_data do |ch, data|
+              print data
+            end
+            channel.on_extended_data do |ch, type, data|
+              print data
+            end
+            channel.on_close do |ch|
+              debug "Terminating ... "
+            end
+            channel.on_request("exit-status") do |ch, data|
+              exit_status = data.read_long
+            end
+            yield channel if block_given?
+            channel.eof!
+          end
+        end
+        session.loop
+        #:nocov:
+      end
+      raise RHC::SSHCommandFailed.new(exit_status) if exit_status != 0
+    rescue Errno::ECONNREFUSED => e
+      debug_error e
+      raise RHC::SSHConnectionRefused.new(host, username)
+    rescue Net::SSH::AuthenticationFailed => e
+      debug_error e
+      raise RHC::SSHAuthenticationFailed.new(host, username)
+    rescue SocketError => e
+      debug_error e
+      raise RHC::ConnectionFailed, "The connection to #{host} failed: #{e.message}"
+    end
+
+
+    # Public: Run ssh command on remote host and pipe the specified
+    # file contents to the command input
+    #
+    # host - The String of the remote hostname to ssh to.
+    # username - The String username of the remote user to ssh as.
+    # command - The String command to run on the remote host.
+    # filename - The String path to file to send.
+    #
+    def ssh_send_file_ruby(host, username, command, filename)
+      filename = File.expand_path(filename)
+      ssh_ruby(host, username, command) do |channel|
+        File.open(filename, 'rb') do |file|
+          file.chunk(1024) do |chunk|
+            channel.send_data chunk
+          end
+        end
+      end
+    end
+
+    # Public: Run ssh command on remote host and pipe the specified
+    # url contents to the command input
+    #
+    # host - The String of the remote hostname to ssh to.
+    # username - The String username of the remote user to ssh as.
+    # command - The String command to run on the remote host.
+    # content_url - The url with the content to pipe to command.
+    #
+    def ssh_send_url_ruby(host, username, command, content_url)
+      content_url = URI.parse(URI.encode(content_url.to_s))
+      ssh_ruby(host, username, command) do |channel|
+        HTTPClient.new.get_content(content_url) do |chunk|
+          channel.send_data chunk
+        end
+      end
+    end
+
+    # Public: Generate an SSH key and store it in ~/.ssh/id_rsa
+    #
+    # type - The String type RSA or DSS.
+    # bits - The Integer value for number of bits.
+    # comment - The String comment for the key
+    #
+    # Examples
+    #
+    #  generate_ssh_key_ruby
+    #  # => /home/user/.ssh/id_rsa.pub
+    #
+    # Returns nil on failure or public key location as a String on success
+    def generate_ssh_key_ruby(type="RSA", bits = 2048, comment = "OpenShift-Key")
+      key = RHC::Vendor::SSHKey.generate(:type => type,
+                                         :bits => bits,
+                                         :comment => comment)
+      ssh_dir = RHC::Config.ssh_dir
+      priv_key = RHC::Config.ssh_priv_key_file_path
+      pub_key = RHC::Config.ssh_pub_key_file_path
+
+      if File.exists?(priv_key)
+        say "SSH key already exists: #{priv_key}.  Reusing..."
+        return nil
+      else
+        unless File.exists?(ssh_dir)
+          FileUtils.mkdir_p(ssh_dir)
+          File.chmod(0700, ssh_dir)
+        end
+        File.open(priv_key, 'w') {|f| f.write(key.private_key)}
+        File.chmod(0600, priv_key)
+        File.open(pub_key, 'w') {|f| f.write(key.ssh_public_key)}
+
+        ssh_add
+      end
+      pub_key
+    end
+
+    def exe?(executable)
+      ENV['PATH'].split(File::PATH_SEPARATOR).any? do |directory|
+        File.executable?(File.join(directory, executable.to_s))
+      end
+    end
+
+    # For Net::SSH versions (< 2.0.11) that does not have
+    # Net::SSH::KeyFactory.load_public_key, we drop to shell to get
+    # the key's fingerprint
+    def ssh_keygen_fallback(path)
+      fingerprint = `ssh-keygen -lf #{path} 2>&1`.split(' ')[1]
+
+      if $?.exitstatus != 0
+        error "Unable to compute SSH public key finger print for #{path}"
+      end
+      fingerprint
+    end
+
+    def fingerprint_for_local_key(key)
+      Net::SSH::KeyFactory.load_public_key(key).fingerprint
+    rescue NoMethodError, NotImplementedError => e
+      ssh_keygen_fallback key
+      nil
+    rescue OpenSSL::PKey::PKeyError, Net::SSH::Exception => e
+      error e.message
+      nil
+    rescue => e
+      debug e.message
+      nil
+    end
+
+    def fingerprint_for_default_key
+      fingerprint_for_local_key(RHC::Config.ssh_pub_key_file_path)
+    end
+
+    # for an SSH public key specified by 'key', return a triple
+    # [type, content, comment]
+    # which is basically the space-separated list of the SSH public key content
+    def ssh_key_triple_for(key)
+      begin
+        IO.read(key).chomp.split
+      rescue Errno::ENOENT => e
+        raise ::RHC::KeyFileNotExistentException.new("File '#{key}' does not exist.")
+      rescue Errno::EACCES => e
+        raise ::RHC::KeyFileAccessDeniedException.new("Access denied to '#{key}'.")
+      end
+    end
+
+    def ssh_key_triple_for_default_key
+      ssh_key_triple_for(RHC::Config.ssh_pub_key_file_path)
+    end
+
+    # check the version of SSH that is installed
+    def ssh_version
+      @ssh_version ||= `ssh -V 2>&1`.strip
+    end
+
+    # return whether or not SSH is installed
+    def has_ssh?
+      @has_ssh ||= begin
+        @ssh_version = nil
+        ssh_version
+        $?.success?
+      rescue
+        false
+      end
+    end
+
+    # return supplied ssh executable, if valid (executable, searches $PATH).
+    # if none was supplied, return installed ssh, if any.
+    def check_ssh_executable!(path)
+      if not path
+        raise RHC::InvalidSSHExecutableException.new("No system SSH available. Please use the --ssh option to specify the path to your SSH executable, or install SSH.") unless has_ssh?
+        'ssh'
+      else
+        bin_path = path.split(' ').first
+        raise RHC::InvalidSSHExecutableException.new("SSH executable '#{bin_path}' does not exist.") unless File.exist?(bin_path) or exe?(bin_path)
+        raise RHC::InvalidSSHExecutableException.new("SSH executable '#{bin_path}' is not executable.") unless File.executable?(bin_path) or exe?(bin_path)
+        path
+      end
+    end
+
+    private
+
+    def ssh_add
+      if exe?('ssh-add')
+        #:nocov:
+        `ssh-add 2>&1`
+        #:nocov:
+      end
+    end
+  end
+end

data/lib/rhc/tar_gz.rb

@@ -0,0 +1,51 @@
+require 'stringio'
+require 'archive/tar/minitar'
+include Archive::Tar
+
+TAR_BIN = File.executable?('/usr/bin/gnutar') ? '/usr/bin/gnutar' : 'tar'
+
+module RHC
+
+  module TarGz
+
+    def self.contains(filename, search, force_ruby=false)
+      
+      return false if ! (File.file? filename and File.basename(filename).downcase =~ /.\.t(ar\.)?gz$/i)
+
+      regex = Regexp.new search
+      if RHC::Helpers.windows? or RHC::Helpers.mac? or force_ruby
+        begin
+          zlib::GzipReader.open(filename) do |gz|
+            Minitar::Reader.open gz do |tar|
+              tar.each_entry do |entry|
+                if entry.full_name =~ regex
+                  return true
+                end
+              end
+            end
+          end
+        rescue zlib::GzipFile::Error, zlib::GzipFile::Error
+          false
+        end
+      else
+        # combining STDOUT and STDERR (i.e., 2>&1) does not suppress output
+        # when the specs run via 'bundle exec rake spec'
+        system "#{TAR_BIN} --wildcards -tf '#{filename}' '#{regex.source}' 2>/dev/null >/dev/null"
+      end
+    end
+
+    private
+      def self.zlib
+        #:nocov:
+        require 'zlib' rescue nil
+        if defined? Zlib::GzipReader 
+          Zlib
+        else
+          require 'rhc/vendor/zliby'
+          RHC::Vendor::Zlib
+        end
+        #:nocov:
+      end
+  end
+
+end

data/lib/rhc/usage_templates/command_help.erb

@@ -0,0 +1,51 @@
+Usage: <%= Array(program :name).first %> <%= @command.name %> <%= @command.syntax %>
+
+<%= @command.description || @command.summary %>
+<% if @actions.blank? or @command.root? and @command.info[:method].present? -%>
+
+<% unless @command.info[:args].blank? or @command.options.all?{ |o| o[:hide] or o[:switches].present? } -%>
+
+Arguments
+<%= table(
+	  @command.info[:args].select do |opt|
+	  	not opt[:hide] and not opt[:switches].present?
+	  end.map do |opt|
+	  	[opt[:name], opt[:description]]
+	  end,
+	  table_args('  ', 25)
+	).join("\n") %>
+<% end -%>
+<% unless @command.options.blank? or @command.options.all?{ |o| o[:hide] } -%>
+
+Options
+<%= table(
+	  @command.options.select do |opt|
+	  	not opt[:hide]
+	  end.map do |opt|
+	  	[opt[:switches].join(', '), opt[:description]]
+	  end,
+	  table_args('  ', 25)
+	).join("\n") %>
+<% end -%>
+
+Global Options
+<%= table(
+	  @global_options.select do |opt|
+	  	not (opt[:hide] || @command.options.any?{ |o| (o[:switches] & opt[:switches]).present? })
+	  end.map do |opt|
+	  	[opt[:switches].join(', '), opt[:description]]
+	  end,
+	  table_args('  ', 25)
+	).join("\n") %>
+
+  See '<%= Array(program :name).first %> help options' for a full list of global options.
+<% end -%>
+<% if @actions.present? -%>
+
+List of Actions
+<%= table(@actions.map{ |a| [a[:name], a[:summary]] }, table_args('  ', 13)).join("\n") %>
+<% if @command.default_action? -%>
+
+The default action for this resource is '<%= @command.default_action %>'
+<% end -%>
+<% end -%>

data/lib/rhc/usage_templates/command_syntax_help.erb

@@ -0,0 +1,11 @@
+Usage: <%= Array(program :name).first %> <%= @command.name %><%= " #{@command.syntax}" if @command.syntax %>
+<% unless @command.options.blank? or @command.options.all?{ |o| o[:hide] } -%>
+Pass '--help' to see the full list of options
+<% end -%>
+<% unless @actions.nil? or @actions.empty? -%>
+
+<%= @command.description || @command.summary %>
+
+List of Actions
+<%= table(@actions.map{ |a| [a[:name], a[:summary]] }, table_args('  ', 18)).join("\n") %>
+<% end -%>