rhc 0.92.11 → 0.93.18

data/lib/rhc-rest.rb

@@ -1,7 +1,6 @@
 require 'rubygems'
 require 'rest-client'
 require 'logger'
-require 'json'
 require 'rhc-rest/exceptions/exceptions'
 require 'rhc-rest/application'
 require 'rhc-rest/cartridge'
@@ -9,6 +8,7 @@ require 'rhc-rest/client'
 require 'rhc-rest/domain'
 require 'rhc-rest/key'
 require 'rhc-rest/user'
+require 'rhc/helpers'
 
 @@end_point = ""
 @@headers = {:accept => :json}
@@ -24,7 +24,7 @@ module Rhc
     end
 
     def parse_response(response)
-      result = JSON.parse(response)
+      result = RHC::Json.decode(response)
       type = result['type']
       data = result['data']
       case type
@@ -92,7 +92,7 @@ module Rhc
     def process_error_response(response)
       messages = Array.new
       begin
-        result = JSON.parse(response)
+        result = RHC::Json.decode(response)
         messages = result['messages']
       rescue Exception => e
         logger.debug "Response did not include a message from server" if @mydebug

data/lib/rhc-rest/client.rb

@@ -13,7 +13,7 @@ module Rhc
         request = RestClient::Request.new(:url => end_point, :method => :get, :headers => @@headers)
         begin
           response = request.execute
-          result = JSON.parse(response)
+          result = RHC::Json.decode(response)
           @links = send(request)
         rescue RestClient::ExceptionWithResponse => e
             logger.error "Failed to get API #{e.response}"

data/lib/rhc-rest/domain.rb

@@ -24,7 +24,7 @@ module Rhc
         end
         timeout = nil
         if options[:scale]
-          timeout = 180 # 3 minute timeout for scalable app
+          timeout = 300 # 5 minute timeout for scalable app
         end
         request = RestClient::Request.new(:url => url, :method => method, :headers => @@headers, :payload => payload, :timeout => timeout)
         return send(request)

data/lib/rhc.rb

@@ -0,0 +1,20 @@
+# require 'rhc/version' #FIXME gem should know version
+# FIXME Remove rubygems from requirements, ensure library is correct
+
+# Only require external gem dependencies here
+require 'rest_client'
+require 'logger'
+
+# Extend core methods
+require 'rhc/core_ext'
+
+module RHC
+  module Commands; end
+
+  autoload :Helpers,  'rhc/helpers'
+end
+
+# Replace me with proper autoloads on the module RHC
+require 'rhc-common'
+require 'rhc-rest'
+

data/lib/rhc/cli.rb

@@ -0,0 +1,38 @@
+require 'rhc'
+require 'commander'
+require 'commander/runner'
+require 'commander/delegates'
+require 'rhc/commands'
+
+include Commander::UI
+include Commander::UI::AskForClass
+
+module RHC
+  #
+  # Run and execute a command line session with the RHC tools.
+  #
+  # You can invoke the CLI with:
+  #   bundle exec ruby -e 'require "rhc/cli"; RHC::CLI.start(ARGV);' -- <arguments>
+  #
+  # from the gem directory.
+  #
+  module CLI
+
+    extend Commander::Delegates
+
+    def self.set_terminal
+      $terminal.wrap_at = HighLine::SystemExtensions.terminal_size.first - 5 rescue 80 if $stdin.tty?
+    end
+
+    def self.start(args)
+      Commander::Runner.instance_variable_set :@singleton, Commander::Runner.new(args)
+
+      program :name,        'rhc'
+      program :version,     '0.0.0' #FIXME pull from versions.rb
+      program :description, 'Command line interface for OpenShift.'
+
+      RHC::Commands.load.to_commander
+      exit(run! || 0)
+    end
+  end
+end

data/lib/rhc/client.rb

@@ -0,0 +1,15 @@
+class RHC::Client
+  def initialize() #auth info
+  end
+
+  include RHC::Helpers
+
+  def get(uri, headers={})
+    # absolute uris are called directly, relative uris are called with
+    # the rest api root, and server relative uris are called against the
+    # host.  Allow simple templatization via t()
+  end
+  def t(uri, opts)
+    # templatize uri using AddressableTemplate and opts
+  end
+end

data/lib/rhc/commands.rb

@@ -0,0 +1,32 @@
+require 'rhc/config'
+
+module RHC
+  module Commands 
+    def self.load
+      Dir[File.join(File.dirname(__FILE__), "commands", "*.rb")].each do |file|
+        require file
+      end
+      self
+    end
+    def self.add(opts)
+      commands[opts[:name]] = opts
+    end
+    def self.to_commander(instance=Commander::Runner.instance)
+      commands.each_pair do |name, opts|
+        instance.command name do |c|
+          c.option '--config PATH', String, 'Path of alternate config'
+          c.when_called do |args, options|
+            RHC::Config.set_opts_config(options.config) if options.config
+            opts[:class].new(args, options).send(opts[:method])
+          end
+        end
+      end
+      self
+    end
+
+    protected
+      def self.commands
+        @commands ||= {}
+      end
+  end
+end

data/lib/rhc/commands/base.rb

@@ -0,0 +1,67 @@
+require 'commander'
+require 'commander/delegates'
+require 'rhc/helpers'
+
+class RHC::Commands::Base
+
+  attr_reader :args, :options
+
+  def initialize(args=[], options={})
+    @args, @options = args, options
+  end
+
+  protected
+    include RHC::Helpers
+
+    def application
+      #@application ||= ... identify current application or throw,
+      #                     indicating one is needed.  Should check
+      #                     options (commands which have it as an ARG
+      #                     should set it onto options), then check
+      #                     current git repo for remote, fail.
+    end
+
+    def client
+      #@client ||= ... Return a client object capable of making calls
+      #                to the OpenShift API that transforms intent
+      #                and options, to remote calls, and then handle
+      #                the output (or failures) into exceptions and
+      #                formatted object output.  Most interactions 
+      #                should be through this call pattern.
+      #
+      #                Initialize with auth (a separate responsibility
+      #                object).
+    end
+
+    class InvalidCommand < StandardError ; end
+
+    def self.inherited(klass)
+      unless klass == RHC::Commands::Base
+      end
+    end
+
+    def self.method_added(method)
+      return if self == RHC::Commands::Base
+      return if private_method_defined? method
+      return if protected_method_defined? method
+
+      method_name = method.to_s == 'run' ? nil : method.to_s
+      name = [method_name]
+      name.unshift(self.object_name).compact!
+      raise InvalidCommand, "Either object_name must be set or a non default method defined" if name.empty?
+      RHC::Commands.add({
+        :name => name.join(' '),
+        :class => self,
+        :method => method,
+      });
+    end
+
+    def self.object_name(value=nil)
+      @object_name ||= begin
+          value ||= if self.name && !self.name.empty?
+            self.name.split('::').last
+          end
+          value.to_s.downcase if value
+        end
+    end
+end

data/lib/rhc/commands/server.rb

@@ -0,0 +1,24 @@
+require 'rhc/commands/base'
+
+module RHC::Commands
+  class Server < Base
+    def run
+      status = decode_json(RestClient.get("https://#{openshift_server}/app/status/status.json").body)
+      open = status['open']
+
+      (success 'All systems running fine' and return 0) if open.blank?
+
+      open.each do |i|
+        i = i['issue']
+        say color("%-3s %s" % ["##{i['id']}", i['title']], :bold)
+        items = i['updates'].map{ |u| [u['description'], date(u['created_at'])] }
+        items.unshift ['Opened', date(i['created_at'])]
+        table(items, :align => [nil,:right], :join => '  ').each{ |s| say "    #{s}" }
+      end
+      say "\n"
+      warn pluralize(open.length, "open issue")
+
+      open.length #exit with the count of open items
+    end
+  end
+end

data/lib/rhc/config.rb

@@ -0,0 +1,141 @@
+require 'parseconfig'
+
+module RHC
+  module Config
+    def self.initialize
+      @@defaults = ParseConfig.new()
+      @@global_config = nil
+      @@local_config = nil
+      @@opts_config = nil
+      @@default_proxy = nil
+      @@env_config = ParseConfig.new()
+
+      @@defaults.add('libra_server', 'openshift.redhat.com')
+      @@env_config.add('libra_server', ENV['LIBRA_SERVER']) if ENV['LIBRA_SERVER']
+
+      #
+      # Config paths... /etc/openshift/express.conf or $GEM/conf/express.conf -> ~/.openshift/express.conf
+      #
+
+      @@conf_name = 'express.conf'
+      _linux_cfg = '/etc/openshift/' + @@conf_name
+      _gem_cfg = File.join(File.expand_path(File.dirname(__FILE__) + "/../../conf"), @@conf_name)
+
+      config_path = File.exists?(_linux_cfg) ? _linux_cfg : _gem_cfg
+      @@home_dir = File.expand_path("~")
+      @@home_conf_path = File.join(@@home_dir, '.openshift')
+      @@local_config_path = File.join(@@home_conf_path, @@conf_name)
+
+      begin
+        @@global_config = ParseConfig.new(config_path)
+        @@local_config = ParseConfig.new(File.expand_path(@@local_config_path)) if File.exists?(@@local_config_path)
+      rescue Errno::EACCES => e
+        puts "Could not open config file: #{e.message}"
+        exit 253
+      end
+    end
+
+    self.initialize
+
+    # used for tests
+    def self.home_dir=(home_dir)
+      @@home_dir=home_dir
+      @@home_conf_path = File.join(@@home_dir, '.openshift')
+      @@local_config_path = File.join(@@home_conf_path, @@conf_name)
+    end
+
+    def self.get_value(key)
+      # evaluate in cascading order
+      configs = [@@opts_config, @@env_config, @@local_config, @@global_config, @@defaults]
+      result = nil
+      configs.each do |conf|
+        result = conf.get_value(key) if !conf.nil?
+        break if !result.nil?
+      end
+
+      result
+    end
+
+    # Public: configures the default user for this session
+    def self.config_user(username)
+      @@defaults.add('default_rhlogin', username)
+    end
+
+    def self.set_local_config(confpath)
+      begin
+        @@local_config = ParseConfig.new(File.expand_path(confpath))
+      rescue Errno::EACCES => e
+        puts "Could not open config file: #{e.message}"
+        exit 253
+      end
+    end
+
+    def self.set_opts_config(confpath)
+      begin
+        @@opts_config = ParseConfig.new(File.expand_path(confpath))
+      rescue Errno::EACCES => e
+        puts "Could not open config file: #{e.message}"
+        exit 253
+      end
+    end
+
+    def self.check_cpath(opts)
+      unless opts["config"].nil?
+        opts_config_path = File.expand_path(opts["config"])
+        if !File.readable?(opts_config_path)
+          puts "Could not open config file: #{@opts_config_path}"
+          exit 253
+        else
+          set_opts_config(opts_config_path)
+        end
+      end
+    end
+
+    def self.has_global_config?
+      !@@global_config.nil?
+    end
+
+    def self.has_local_config?
+      !@@local_config.nil?
+    end
+
+    def self.has_opts_config?
+      !@@opts_config.nil?
+    end
+
+    # Public: convinience function to see if we should run the wizard
+    def self.should_run_wizard?
+      not (has_local_config? or has_opts_config?)
+    end
+
+    def self.local_config_path
+      @@local_config_path
+    end
+
+    def self.home_conf_path
+      @@home_conf_path
+    end
+
+    def self.home_dir
+      @@home_dir
+    end
+
+    def self.default_proxy
+      #
+      # Check for proxy environment
+      #
+      if @@default_proxy.nil?
+        if ENV['http_proxy']
+          if ENV['http_proxy']!~/^(\w+):\/\// then
+            ENV['http_proxy']="http://" + ENV['http_proxy']
+          end
+          proxy_uri=URI.parse(ENV['http_proxy'])
+          @@default_proxy = Net::HTTP::Proxy(proxy_uri.host, proxy_uri.port, proxy_uri.user, proxy_uri.password)
+        else
+          @@default_proxy = Net::HTTP
+        end
+      end
+      @@default_proxy
+    end
+  end
+end

data/lib/rhc/core_ext.rb

@@ -0,0 +1,15 @@
+# From Rails core_ext/object.rb
+require 'rhc/json'
+
+class Object
+  def present?
+    !blank?
+  end
+  def blank?
+    respond_to?(:empty?) ? empty? : !self
+  end
+
+  def to_json
+    RHC::Json.encode(self)
+  end
+end

data/lib/rhc/helpers.rb

@@ -0,0 +1,142 @@
+require 'commander/user_interaction'
+require 'rhc/config'
+
+module RHC
+  module Helpers
+
+    # helpers always have Commander UI available
+    include Commander::UI
+    include Commander::UI::AskForClass
+
+    extend self
+
+    def decode_json(s)
+      RHC::Vendor::OkJson.decode(s)
+    end
+
+    def date(s)
+      now = Time.now
+      d = datetime_rfc3339(s)
+      if now.year == d.year
+        return d.strftime('%l:%M %p').strip if now.yday == d.yday
+      end
+      d.strftime('%b %d %l:%M %p')
+    end
+
+    def datetime_rfc3339(s)
+      DateTime.strptime(s, '%Y-%m-%dT%H:%M:%S%z')
+      # Replace with d = DateTime.rfc3339(s)
+    end
+
+    def openshift_server
+      RHC::Config.get_value('libra_server')
+    end
+
+    def success(*args)
+      args.each{ |a| say color(a, :green) }
+    end
+    def warn(*args)
+      args.each{ |a| say color(a, :yellow) }
+    end
+
+    def color(s, color)
+      $terminal.color(s, color)
+    end
+
+    def pluralize(count, s)
+      count == 1 ? "#{count} #{s}" : "#{count} #{s}s"
+    end
+
+    def table(items, opts={}, &block)
+      items = items.map &block if block_given?
+      columns = []
+      max = items.each do |item|
+        item.each_with_index do |s, i|
+          item[i] = s.to_s
+          columns[i] = [columns[i] || 0, s.length].max if s.respond_to?(:length)
+        end
+      end
+      align = opts[:align] || []
+      join = opts[:join] || ' '
+      items.map do |item|
+        item.each_with_index.map{ |s,i| s.send((align[i] == :right ? :rjust : :ljust), columns[i], ' ') }.join(join).strip
+      end
+    end
+
+      ##
+    # section
+    #
+    # highline helper mixin which correctly formats block of say and ask
+    # output to have correct margins.  section remembers the last margin
+    # used and calculates the relitive margin from the previous section.
+    # For example:
+    #
+    # section(bottom=1) do
+    #   say "Hello"
+    # end
+    #
+    # section(top=1) do
+    #   say "World"
+    # end
+    #
+    # Will output:
+    #
+    # > Hello
+    # >
+    # > World 
+    #
+    # with only one newline between the two.  Biggest margin wins.
+    #
+    # params:
+    #  top - top margin specified in lines
+    #  bottom - bottom margin specified in line
+    #
+    @@section_bottom_last = 0
+    def section(params={}, &block)
+      top = params[:top]
+      top = 0 if top.nil?
+      bottom = params[:bottom]
+      bottom = 0 if bottom.nil?
+
+      # add more newlines if top is greater than the last section's bottom margin
+      top_margin = @@section_bottom_last
+
+      # negitive previous bottoms indicate that an untracked newline was
+      # printed and so we do our best to negate it since we can't remove it
+      if top_margin < 0
+        top += top_margin
+        top_margin = 0
+      end
+
+      until top_margin >= top
+        say "\n"
+        top_margin += 1
+      end
+
+      block.call
+
+      bottom_margin = 0
+      until bottom_margin >= bottom
+        say "\n"
+        bottom_margin += 1
+      end
+
+      @@section_bottom_last = bottom
+    end
+
+    ##
+    # paragraph
+    #
+    # highline helper which creates a section with margins of 1, 1
+    #
+    def paragraph(&block)
+      section(:top => 1, :bottom => 1, &block)
+    end
+
+    # Platform helpers
+    def jruby? ; RUBY_PLATFORM =~ /java/i end
+    def windows? ; RUBY_PLATFORM =~ /win(32|dows|ce)|djgpp|(ms|cyg|bcc)win|mingw32/i end
+    def unix? ; !jruby? && !windows? end
+
+  end
+end