jdc 0.1.2 → 0.2.0

data/lib/jdc/cli.rb

@@ -0,0 +1,544 @@
+require "yaml"
+require "socket"
+require "net/http"
+require "multi_json"
+require "fileutils"
+
+require "mothership"
+
+require "jfoundry"
+
+require "jdc/constants"
+require "jdc/errors"
+require "jdc/spacing"
+
+require "jdc/cli/help"
+require "jdc/cli/interactive"
+require "jdc/cli/login_requirements"
+
+
+$cf_asked_auth = false
+
+module JDC 
+  class CLI < Mothership
+    include JDC::Interactive
+    include JDC::Spacing
+
+    option :help, :desc => "Show command usage", :alias => "-h",
+      :default => false
+
+    option :http_proxy, :desc => "Connect though an http proxy server", :alias => "--http-proxy",
+      :value => :http_proxy
+
+    option :https_proxy, :desc => "Connect though an https proxy server", :alias => "--https-proxy",
+      :value => :https_proxy
+
+    option :version, :desc => "Print version number", :alias => "-v",
+      :default => false
+
+    option :verbose, :desc => "Print extra information", :alias => "-V",
+      :default => false
+
+    option :force, :desc => "Skip interaction when possible", :alias => "-f",
+      :type => :boolean, :default => proc { input[:script] }
+
+    option :debug, :desc => "Print full stack trace (instead of crash log)",
+           :type => :boolean, :default => false
+
+    option :quiet, :desc => "Simplify output format", :alias => "-q",
+      :type => :boolean, :default => proc { input[:script] }
+
+    option :script, :desc => "Shortcut for --quiet and --force",
+      :type => :boolean, :default => proc { !$stdout.tty? }
+
+    option :color, :desc => "Use colorful output",
+      :type => :boolean, :default => proc { !input[:quiet] }
+
+    option :trace, :desc => "Show API traffic", :alias => "-t",
+      :default => false
+
+
+    def default_action
+      if input[:version]
+        line "jdc #{VERSION}"
+      else
+        super
+      end
+    end
+
+    def check_key
+        unless ENV["ACCESS_KEY"]
+            fail "Please set the env ACCESS_KEY."
+        end
+
+        unless ENV["SECRET_KEY"]
+            fail "Please set the env SECRET_KEY."
+        end
+    end
+
+    def check_target
+      unless client && client.target
+        fail "Please select a target with 'jdc target'."
+      end
+    end
+
+    def check_organization_and_space
+      info = target_info(client.target)
+
+      info_changed = false
+      if (info.key? :organization) && info[:access_key] != ENV['ACCESS_KEY']
+          info.delete(:organization)
+          client.current_organization = nil
+          info_changed = true
+      end
+
+      if (info.key? :space) && info[:access_key] != ENV['ACCESS_KEY']
+          info.delete(:space)
+          client.current_space = nil
+          info_changed = true
+      end
+
+      if info[:access_key] != ENV['ACCESS_KEY']
+          info[:access_key] = ENV['ACCESS_KEY']
+          info_changed = true
+      end
+
+      save_target_info(info, client.target) unless !info_changed
+    end
+
+    def check_logged_in
+      check_target
+      unless client.logged_in?
+        if force?
+          fail "Please log in with 'jdc login'."
+        else
+          line c("Please log in first to proceed.", :warning)
+          line
+          invoke :login
+          invalidate_client
+        end
+      end
+    end
+
+    desc "Help!"
+    input :command, :argument => :optional
+    def help
+      if name = input[:command]
+        if cmd = @@commands[name.gsub("-", "_").to_sym]
+          Mothership::Help.command_help(cmd)
+        else
+          unknown_command(name)
+        end
+      elsif Help.has_groups?
+        puts "#{help_header}"
+
+        Mothership::Help.print_help_groups(@@global, true)
+      else
+        Mothership::Help.basic_help(@@commands, @@global)
+      end
+    end
+
+    def help_header
+    <<EOS
+Jing Dong Foundry Command Line Interface, version [#{JDC::VERSION}]
+  Use 'jdc help [command]' for command details.
+  For docs and support visit http://appengine.jd.com/help/jdc.html
+
+USAGE EXAMPLES
+  $ jdc target api.jd-app.com        <-- sets the JDC instance target where your app will be pushed
+  $ jdc push                         <-- deploys app to current app space on current target
+  $ jdc target -s staging            <-- changes currently targeted app space to 'staging'
+
+EOS
+    end
+
+    def wrap_errors
+      yield
+    rescue JFoundry::Timeout => e
+      err(e.message)
+    rescue Interrupt
+      exit_status 130
+    rescue Mothership::Error
+      raise
+    rescue UserError => e
+      log_error(e)
+      err e.message
+    rescue SystemExit
+      raise
+    rescue UserFriendlyError => e
+      err e.message
+=begin
+    rescue JFoundry::InvalidAuthToken => e
+      line
+      line c("Invalid authentication token. Try logging in again with 'cf login'. If problems continue, please contact your Cloud Operator.", :warning)
+    rescue JFoundry::Forbidden => e
+      if !$cf_asked_auth
+        $cf_asked_auth = true
+
+        line
+        line c("Not authenticated! Try logging in:", :warning)
+
+        # TODO: there's no color here; global flags not being passed
+        # through (mothership bug?)
+        invoke :login
+
+        retry
+      end
+
+      log_error(e)
+
+      err "Denied: #{e.description}"
+=end
+    rescue JFoundry::StagingError => e
+      message = "Application failed to stage"
+      formatted_exception_output(e, message)
+
+    rescue Exception => e
+      formatted_exception_output(e, add_exception_name_to_msg(e))
+    end
+
+    def formatted_exception_output(e, msg)
+      log_error(e)
+      msg << "\ncat #{JDC::CRASH_FILE} # for more details"
+      err msg
+
+      raise if debug?
+    end
+
+    def add_exception_name_to_msg(e)
+      msg = e.class.name
+      msg << ": #{e}" unless e.to_s.empty?
+      msg
+    end
+
+    def execute(cmd, argv, global = {})
+      if input[:help]
+        invoke :help, :command => cmd.name.to_s
+      else
+        wrap_errors do
+          @command = cmd
+          precondition if respond_to? :precondition
+
+          save_token_if_it_changes do
+            super
+          end
+        end
+      end
+    end
+
+    def save_token_if_it_changes
+      return yield unless client
+      yield
+=begin
+      return yield unless client && client.token
+
+      before_token = client.token
+
+      yield
+
+      after_token = client.token
+
+      return unless after_token
+
+      if before_token != after_token
+        info = target_info
+        info[:token] = after_token.auth_header
+        save_target_info(info)
+      end
+=end
+    end
+
+    def log_error(e)
+      ensure_config_dir
+
+      msg = e.class.name
+      msg << ": #{e}" unless e.to_s.empty?
+
+      crash_file = File.expand_path(JDC::CRASH_FILE)
+
+      FileUtils.mkdir_p(File.dirname(crash_file))
+
+      File.open(crash_file, "w") do |f|
+        f.puts "Time of crash:"
+        f.puts "  #{Time.now}"
+        f.puts ""
+        f.puts msg
+        f.puts ""
+
+        if e.respond_to?(:request_trace)
+          f.puts "<<<"
+          f.puts e.request_trace
+        end
+
+        if e.respond_to?(:response_trace)
+          f.puts e.response_trace
+          f.puts ">>>"
+          f.puts ""
+        end
+
+        jdc_dir = File.expand_path("../../../..", __FILE__) + "/"
+        e.backtrace.each do |loc|
+          if loc =~ /\/gems\//
+            f.puts loc.sub(/.*\/gems\//, "")
+          else
+            f.puts loc.sub(jdc_dir, "")
+          end
+        end
+      end
+    end
+
+    def quiet?
+      input[:quiet]
+    end
+
+    def force?
+      input[:force]
+    end
+
+    def debug?
+      !!input[:debug]
+    end
+
+    def color_enabled?
+      input[:color]
+    end
+
+    def verbose?
+      input[:verbose]
+    end
+
+    def user_colors
+      return @user_colors if @user_colors
+
+      colors = File.expand_path(COLORS_FILE)
+
+      @user_colors = super.dup
+
+      # most terminal schemes are stupid, so use cyan instead
+      @user_colors.each do |k, v|
+        if v == :blue
+          @user_colors[k] = :cyan
+        end
+      end
+
+      if File.exists?(colors)
+        YAML.load_file(colors).each do |k, v|
+          @user_colors[k.to_sym] = v.to_sym
+        end
+      end
+
+      @user_colors
+    end
+
+    def err(msg, status = 1)
+      $stderr.puts c(msg, :error)
+      exit_status status
+    end
+
+    def fail(msg)
+      raise UserError, msg
+    end
+
+    def table(headers, rows)
+      tabular(
+        !quiet? && headers.collect { |h| h && b(h) },
+        *rows)
+    end
+
+    def name_list(xs)
+      if xs.empty?
+        d("none")
+      else
+        xs.collect { |x| c(x.name, :name) }.join(", ")
+      end
+    end
+
+    def sane_target_url(url)
+      unless url =~ /^https?:\/\//
+        begin
+          TCPSocket.new(url, Net::HTTP.https_default_port)
+          url = "https://#{url}"
+        rescue Errno::ECONNREFUSED, SocketError, Timeout::Error
+          url = "http://#{url}"
+        end
+      end
+
+      url.gsub(/\/$/, "")
+    end
+
+    def one_of(*paths)
+      paths.each do |p|
+        exp = File.expand_path(p)
+        return exp if File.exist? exp
+      end
+
+      File.expand_path(paths.first)
+    end
+
+    def client_target
+      return File.read(target_file).chomp if File.exists?(target_file)
+      sane_target_url(JDC::DEFAULT_API_URL)
+    end
+
+    def ensure_config_dir
+      config = File.expand_path(JDC::CONFIG_DIR)
+      FileUtils.mkdir_p(config) unless File.exist? config
+    end
+
+    def set_target(url)
+      ensure_config_dir
+
+      File.open(File.expand_path(JDC::TARGET_FILE), "w") do |f|
+        f.write(sane_target_url(url))
+      end
+
+      invalidate_client
+    end
+
+    def targets_info
+      new_toks = File.expand_path(JDC::TOKENS_FILE)
+
+      info =
+        if File.exist? new_toks
+          YAML.load_file(new_toks)
+        end
+
+      info ||= {}
+
+      normalize_targets_info(info)
+    end
+
+    def normalize_targets_info(info_by_url)
+      info_by_url.reduce({}) do |hash, pair|
+        key, value = pair
+        hash[key] = value.is_a?(String) ? { :token => value } : value
+        hash
+      end
+    end
+
+    def target_info(target = client_target)
+      targets_info[target] || {}
+    end
+
+    def save_targets(ts)
+      ensure_config_dir
+
+      File.open(File.expand_path(JDC::TOKENS_FILE), "w") do |io|
+        YAML.dump(ts, io)
+      end
+    end
+
+    def save_target_info(info, target = client_target)
+      ts = targets_info
+      ts[target] = info
+      save_targets(ts)
+    end
+
+    def remove_target_info(target = client_target)
+      ts = targets_info
+      ts.delete target
+      save_targets(ts)
+    end
+
+    def invalidate_client
+      @@client = nil
+      client
+    end
+
+    def client(target = client_target)
+      return @@client if defined?(@@client) && @@client
+      return unless target
+
+      info = target_info(target)
+      #token = info[:token] && JFoundry::AuthToken.from_hash(info)
+
+      fail "V1 targets are no longer supported." if info[:version] == 1
+
+      @@client = build_client(target)
+
+      @@client.trace = input[:trace]
+
+      uri = URI.parse(target)
+      @@client.log = File.expand_path("#{LOGS_DIR}/#{uri.host}.log")
+
+      info_changed = false
+      unless info.key? :version
+        info[:version] = @@client.version
+        info_changed = true
+      end
+
+      unless info.key? :access_key
+        info[:access_key] = ENV['ACCESS_KEY'] 
+        info_changed = true
+      end
+
+      save_target_info(info, target) unless !info_changed
+
+      @@client.current_organization = @@client.organization(info[:organization]) if info[:organization]
+      @@client.current_space = @@client.space(info[:space]) if info[:space]
+
+      @@client
+    rescue JFoundry::InvalidTarget
+    end
+
+    def build_client(target)
+      client = JFoundry::V2::Client.new(target, ENV['ACCESS_KEY'], ENV['SECRET_KEY'], JDC::VERSION)
+      client.http_proxy = input[:http_proxy] || ENV['HTTP_PROXY'] || ENV['http_proxy']
+      client.https_proxy = input[:https_proxy] || ENV['HTTPS_PROXY'] || ENV['https_proxy']
+      client
+    end
+
+    def fail_unknown(display, name)
+      fail("Unknown #{display} '#{name}'.")
+    end
+
+    class << self
+      def client
+        @@client
+      end
+
+      def client=(c)
+        @@client = c
+      end
+
+      private
+
+      def find_by_name(display, &blk)
+        proc { |name, *args|
+          choices, _ = args
+          choices ||= instance_exec(&blk) if block_given?
+
+          choices.find { |c| c.name == name } ||
+            fail_unknown(display, name)
+        }
+      end
+
+      def by_name(what, display = what)
+        proc { |name, *_|
+          client.send(:"#{what}_by_name", name) ||
+            fail_unknown(display, name)
+        }
+      end
+
+      def find_by_name_insensitive(display, &blk)
+        proc { |name, *args|
+          choices, _ = args
+          choices ||= instance_exec(&blk) if block_given?
+
+          choices.find { |c| c.name.upcase == name.upcase } ||
+            fail_unknown(display, name)
+        }
+      end
+    end
+
+    private
+
+    def target_file
+      File.expand_path(JDC::TARGET_FILE)
+    end
+
+    def tokens_file
+      File.expand_path(JDC::TOKENS_FILE)
+    end
+  end
+end

data/lib/jdc/constants.rb

@@ -0,0 +1,11 @@
+module JDC 
+  CONFIG_DIR = "~/.jdc".freeze
+
+  LOGS_DIR        = "#{CONFIG_DIR}/logs".freeze
+  PLUGINS_FILE    = "#{CONFIG_DIR}/plugins.yml".freeze
+  TARGET_FILE     = "#{CONFIG_DIR}/target".freeze
+  TOKENS_FILE     = "#{CONFIG_DIR}/tokens.yml".freeze
+  COLORS_FILE     = "#{CONFIG_DIR}/colors.yml".freeze
+  CRASH_FILE      = "#{CONFIG_DIR}/crash".freeze
+  DEFAULT_API_URL = "api.jd-app.com".freeze
+end

data/lib/jdc/errors.rb

@@ -0,0 +1,19 @@
+module JDC 
+  class UserFriendlyError < RuntimeError
+    def initialize(msg)
+      @message = msg
+    end
+
+    def to_s
+      @message
+    end
+  end
+
+  class UserError < UserFriendlyError; end
+
+  class NotAuthorized < UserError
+    def initialize
+      @message = "Not authorized."
+    end
+  end
+end

data/lib/jdc/object_extensions.rb

@@ -0,0 +1,15 @@
+class Object
+  def try(*a, &b)
+    if a.empty? && block_given?
+      yield self
+    else
+      __send__(*a, &b)
+    end
+  end
+end
+
+class NilClass
+  def try(*a, &b)
+    nil
+  end
+end

data/lib/jdc/plugin.rb

@@ -0,0 +1,56 @@
+require "set"
+require "yaml"
+
+require "jdc/constants"
+require "jdc/cli"
+
+module JDC 
+  module Plugin
+    @@plugins = []
+
+    def self.load_all
+      # auto-load gems with 'jdc-plugin' in their name
+      matching =
+        if Gem::Specification.respond_to? :find_all
+          Gem::Specification.find_all do |s|
+            s.name =~ /jdc-plugin/
+          end
+        else
+          Gem.source_index.find_name(/jdc-plugin/)
+        end
+
+      enabled = Set.new(matching.collect(&:name))
+
+      jdc_gems = Gem.loaded_specs["jdc"]
+      ((jdc_gems && jdc_gems.dependencies) || Gem.loaded_specs.values).each do |dep|
+        if dep.name =~ /jdc-plugin/
+          require "#{dep.name}/plugin"
+          enabled.delete dep.name
+        end
+      end
+
+      # allow explicit enabling/disabling of gems via config
+      plugins = File.expand_path(JDC::PLUGINS_FILE)
+      if File.exists?(plugins) && yaml = YAML.load_file(plugins)
+        enabled += yaml["enabled"] if yaml["enabled"]
+        enabled -= yaml["disabled"] if yaml["disabled"]
+      end
+
+      # load up each gem's 'plugin' file
+      #
+      # we require this file specifically so people can require the gem
+      # without it plugging into JDC 
+      enabled.each do |gemname|
+        begin
+          require "#{gemname}/plugin"
+        rescue Gem::LoadError => e
+          puts "Failed to load #{gemname}:"
+          puts "  #{e}"
+          puts
+          puts "You may need to update or remove this plugin."
+          puts
+        end
+      end
+    end
+  end
+end