pebblescape 0.0.1

data/lib/pebbles/command/config.rb

@@ -0,0 +1,147 @@
+require "pebbles/command/base"
+
+# manage app config vars
+#
+class Pebbles::Command::Config < Pebbles::Command::Base
+
+  # config
+  #
+  # display the config vars for an app
+  #
+  # -s, --shell  # output config vars in shell format
+  #
+  #Examples:
+  #
+  # $ pebbles config
+  # A: one
+  # B: two
+  #
+  # $ pebbles config --shell
+  # A=one
+  # B=two
+  #
+  def index
+    validate_arguments!
+
+    vars = if options[:shell]
+             api.get_config_vars(app).body
+           else
+             api.request(
+               :expects  => 200,
+               :method   => :get,
+               :path     => "/apps/#{app}/config_vars",
+               :query    => { "symbolic" => true }
+             ).body
+           end
+
+    if vars.empty?
+      display("#{app} has no config vars.")
+    else
+      vars.each {|key, value| vars[key] = value.to_s}
+      if options[:shell]
+        vars.keys.sort.each do |key|
+          display(%{#{key}=#{vars[key]}})
+        end
+      else
+        styled_header("#{app} Config Vars")
+        styled_hash(vars)
+      end
+    end
+  end
+
+  # config:set KEY1=VALUE1 [KEY2=VALUE2 ...]
+  #
+  # set one or more config vars
+  #
+  #Example:
+  #
+  # $ pebbles config:set A=one
+  # Setting config vars and restarting example... done, v123
+  # A: one
+  #
+  # $ pebbles config:set A=one B=two
+  # Setting config vars and restarting example... done, v123
+  # A: one
+  # B: two
+  #
+  def set
+    unless args.size > 0 and args.all? { |a| a.include?('=') }
+      error("Usage: pebbles config:set KEY1=VALUE1 [KEY2=VALUE2 ...]\nMust specify KEY and VALUE to set.")
+    end
+
+    vars = args.inject({}) do |vars, arg|
+      key, value = arg.split('=', 2)
+      vars[key] = value
+      vars
+    end
+
+    action("Setting config vars and restarting #{app}") do
+      api.put_config_vars(app, vars)
+
+      @status = begin
+        if release = api.get_release(app, 'current').body
+          release['name']
+        end
+      rescue Pebbles::API::Errors::RequestFailed => e
+      end
+    end
+
+    vars.each {|key, value| vars[key] = value.to_s}
+    styled_hash(vars)
+  end
+
+  alias_command "config:add", "config:set"
+
+  # config:get KEY
+  #
+  # display a config value for an app
+  #
+  #Examples:
+  #
+  # $ pebbles config:get A
+  # one
+  #
+  def get
+    unless key = shift_argument
+      error("Usage: pebbles config:get KEY\nMust specify KEY.")
+    end
+    validate_arguments!
+
+    vars = api.get_config_vars(app).body
+    key, value = vars.detect {|k,v| k == key}
+    display(value.to_s)
+  end
+
+  # config:unset KEY1 [KEY2 ...]
+  #
+  # unset one or more config vars
+  #
+  # $ pebbles config:unset A
+  # Unsetting A and restarting example... done, v123
+  #
+  # $ pebbles config:unset A B
+  # Unsetting A and restarting example... done, v123
+  # Unsetting B and restarting example... done, v124
+  #
+  def unset
+    if args.empty?
+      error("Usage: pebbles config:unset KEY1 [KEY2 ...]\nMust specify KEY to unset.")
+    end
+
+    args.each do |key|
+      action("Unsetting #{key} and restarting #{app}") do
+        api.delete_config_var(app, key)
+
+        @status = begin
+          if release = api.get_release(app, 'current').body
+            release['name']
+          end
+        rescue Pebbles::API::Errors::RequestFailed => e
+        end
+      end
+    end
+  end
+
+  alias_command "config:remove", "config:unset"
+
+end

data/lib/pebbles/command/help.rb

@@ -0,0 +1,124 @@
+require "pebbles/command/base"
+
+# list commands and display help
+#
+class Pebbles::Command::Help < Pebbles::Command::Base
+
+  PRIMARY_NAMESPACES = %w( auth apps ps run addons config releases domains logs sharing )
+
+  def index
+    if command = args.shift
+      help_for_command(command)
+    else
+      help_for_root
+    end
+  end
+
+  alias_command "-h", "help"
+  alias_command "--help", "help"
+
+private
+
+  def commands_for_namespace(name)
+    Pebbles::Command.commands.values.select do |command|
+      command[:namespace] == name && command[:command] != name
+    end
+  end
+
+  def namespaces
+    namespaces = Pebbles::Command.namespaces
+    namespaces.delete("app")
+    namespaces
+  end
+
+  def commands
+    Pebbles::Command.commands
+  end
+
+  def skip_namespace?(ns)
+    return true if ns[:description] =~ /DEPRECATED:/
+    return true if ns[:description] =~ /HIDDEN:/
+    false
+  end
+
+  def skip_command?(command)
+    return true if command[:help] =~ /DEPRECATED:/
+    return true if command[:help] =~ /^ HIDDEN:/
+    false
+  end
+
+  def primary_namespaces
+    PRIMARY_NAMESPACES.map { |name| namespaces[name] }.compact
+  end
+
+  def additional_namespaces
+    (namespaces.values - primary_namespaces)
+  end
+
+  def summary_for_namespaces(namespaces)
+    size = longest(namespaces.map { |n| n[:name] })
+    namespaces.sort_by {|namespace| namespace[:name]}.each do |namespace|
+      next if skip_namespace?(namespace)
+      name = namespace[:name]
+      namespace[:description]
+      puts "  %-#{size}s  # %s" % [ name, namespace[:description] ]
+    end
+  end
+
+  def help_for_root
+    puts "Usage: pebbles COMMAND [--app APP] [command-specific-options]"
+    puts
+    puts "Primary help topics, type \"pebbles help TOPIC\" for more details:"
+    puts
+    summary_for_namespaces(primary_namespaces)
+    puts
+    puts "Additional topics:"
+    puts
+    summary_for_namespaces(additional_namespaces)
+    puts
+  end
+
+  def help_for_namespace(name)
+    namespace_commands = commands_for_namespace(name)
+
+    unless namespace_commands.empty?
+      size = longest(namespace_commands.map { |c| c[:banner] })
+      namespace_commands.sort_by { |c| c[:banner].to_s }.each do |command|
+        next if skip_command?(command)
+        command[:summary]
+        puts "  %-#{size}s  # %s" % [ command[:banner], command[:summary] ]
+      end
+    end
+  end
+
+  def help_for_command(name)
+    if command_alias = Pebbles::Command.command_aliases[name]
+      display("Alias: #{name} redirects to #{command_alias}")
+      name = command_alias
+    end
+    if command = commands[name]
+      puts "Usage: pebbles #{command[:banner]}"
+
+      if command[:help].strip.length > 0
+        help = command[:help].split("\n").reject do |line|
+          line =~ /HIDDEN/
+        end
+        puts help[1..-1].join("\n")
+      end
+      puts
+    end
+
+    namespace_commands = commands_for_namespace(name).reject do |command|
+      command[:help] =~ /DEPRECATED/
+    end
+
+    if !namespace_commands.empty?
+      puts "Additional commands, type \"pebbles help COMMAND\" for more details:"
+      puts
+      help_for_namespace(name)
+      puts
+    elsif command.nil?
+      error "#{name} is not a pebbles command. See `pebbles help`."
+    end
+  end
+end

data/lib/pebbles/git.rb

@@ -0,0 +1,69 @@
+require "pebbles/helpers"
+
+module Pebbles::Git
+  extend Pebbles::Helpers
+
+  def self.check_git_version
+    return unless running_on_windows? || running_on_a_mac?
+    if git_is_insecure(git_version)
+      warn_about_insecure_git
+    end
+  end
+
+  def self.git_is_insecure(version)
+    v = Version.parse(version)
+    if v < Version.parse('1.8.5.6')
+      return true
+    end
+    if v >= Version.parse('1.9') && v < Version.parse('1.9.5')
+      return true
+    end
+    if v >= Version.parse('2.0') && v < Version.parse('2.0.5')
+      return true
+    end
+    if v >= Version.parse('2.1') && v < Version.parse('2.1.4')
+      return true
+    end
+    if v >= Version.parse('2.2') && v < Version.parse('2.2.1')
+      return true
+    end
+    return false
+  end
+
+  def self.warn_about_insecure_git
+    warn "Your version of git is #{git_version}. Which has serious security vulnerabilities."
+    warn "More information here: https://blog.heroku.com/archives/2014/12/23/update_your_git_clients_on_windows_and_os_x"
+  end
+
+  private
+
+  def self.git_version
+    version = /git version ([\d\.]+)/.match(`git --version`)
+    error("Git appears to be installed incorrectly\nEnsure that `git --version` outputs the version correctly.") unless version
+    version[1]
+  rescue Errno::ENOENT
+    error("Git must be installed to use pebbles.\nSee instructions here: http://git-scm.com")
+  end
+
+  class Version
+    include Comparable
+
+    attr_accessor :major, :minor, :patch, :special
+
+    def initialize(major, minor=0, patch=0, special=0)
+      @major, @minor, @patch, @special = major, minor, patch, special
+    end
+
+    def self.parse(s)
+      digits = s.split('.').map { |i| i.to_i }
+      Version.new(*digits)
+    end
+
+    def <=>(other)
+      return major <=> other.major unless (major <=> other.major) == 0
+      return minor <=> other.minor unless (minor <=> other.minor) == 0
+      return patch <=> other.patch unless (patch <=> other.patch) == 0
+      return special <=> other.special
+    end
+  end
+end

data/lib/pebbles/helpers.rb

@@ -0,0 +1,284 @@
+module Pebbles
+  module Helpers
+    extend self
+    
+    def home_directory
+      return Dir.home if defined? Dir.home # Ruby 1.9+
+      running_on_windows? ? ENV['USERPROFILE'].gsub("\\","/") : ENV['HOME']
+    end
+
+    def running_on_windows?
+      RUBY_PLATFORM =~ /mswin32|mingw32/
+    end
+
+    def running_on_a_mac?
+      RUBY_PLATFORM =~ /-darwin\d/
+    end
+    
+    def launchy(message, url)
+      action(message) do
+        require("launchy")
+        launchy = Launchy.open(url)
+        if launchy.respond_to?(:join)
+          launchy.join
+        end
+      end
+    end
+    
+    def output_with_bang(message="", new_line=true)
+      return if message.to_s.strip == ""
+      display(format_with_bang(message), new_line)
+    end
+    
+    def format_with_bang(message)
+      return '' if message.to_s.strip == ""
+      " !    " + message.split("\n").join("\n !    ")
+    end
+    
+    def display(msg="", new_line=true)
+      if new_line
+        puts(msg)
+      else
+        print(msg)
+      end
+      $stdout.flush
+    end
+    
+    def debug(*args)
+      $stderr.puts(*args) if debugging?
+    end
+    
+    def debugging?
+      ENV['PEBBLES_DEBUG']
+    end
+    
+    def ask
+      $stdin.gets.to_s.strip
+    end
+    
+    def error(message, report=false)
+      if Pebbles::Helpers.error_with_failure
+        display("failed")
+        Pebbles::Helpers.error_with_failure = false
+      end
+      $stderr.puts(format_with_bang(message))
+      exit(1)
+    end
+    
+    def self.error_with_failure
+      @@error_with_failure ||= false
+    end
+
+    def self.error_with_failure=(new_error_with_failure)
+      @@error_with_failure = new_error_with_failure
+    end
+    
+    def hputs(string='')
+      Kernel.puts(string)
+    end
+    
+    def longest(items)
+      items.map { |i| i.to_s.length }.sort.last
+    end
+    
+    def has_git?
+      %x{ git --version }
+      $?.success?
+    end
+
+    def git(args)
+      return "" unless has_git?
+      flattened_args = [args].flatten.compact.join(" ")
+      %x{ git #{flattened_args} 2>&1 }.strip
+    end
+    
+    def has_git_remote?(remote)
+      git('remote').split("\n").include?(remote) && $?.success?
+    end
+
+    def create_git_remote(remote, url)
+      return if has_git_remote? remote
+      git "remote add #{remote} #{url}"
+      display "Git remote #{remote} added" if $?.success?
+    end
+
+    def update_git_remote(remote, url)
+      return unless has_git_remote? remote
+      git "remote set-url #{remote} #{url}"
+      display "Git remote #{remote} updated" if $?.success?
+    end
+    
+    @@kb = 1024
+    @@mb = 1024 * @@kb
+    @@gb = 1024 * @@mb
+    def format_bytes(amount)
+      amount = amount.to_i
+      return '(empty)' if amount == 0
+      return amount if amount < @@kb
+      return "#{(amount / @@kb).round}k" if amount < @@mb
+      return "#{(amount / @@mb).round}M" if amount < @@gb
+      return "#{(amount / @@gb).round}G"
+    end
+    
+    def json_decode(json)
+      MultiJson.load(json)
+    rescue MultiJson::ParseError
+      nil
+    end
+    
+    def with_tty(&block)
+      return unless $stdin.isatty
+      begin
+        yield
+      rescue
+        # fails on windows
+      end
+    end
+    
+    def action(message, options={})
+      message = "#{message} in organization #{org}" if options[:org]
+      display("#{message}... ", false)
+      Pebbles::Helpers.error_with_failure = true
+      ret = yield
+      Pebbles::Helpers.error_with_failure = false
+      display((options[:success] || "done"), false)
+      if @status
+        display(", #{@status}", false)
+        @status = nil
+      end
+      display
+      ret
+    end
+    
+    def confirm_command(app_to_confirm = app, message=nil)
+      if confirmed_app = Pebbles::Command.current_options[:confirm]
+        unless confirmed_app == app_to_confirm
+          raise(Pebbles::Command::CommandFailed, "Confirmed app #{confirmed_app} did not match the selected app #{app_to_confirm}.")
+        end
+        return true
+      else
+        display
+        message ||= "WARNING: Destructive Action\nThis command will affect the app: #{app_to_confirm}"
+        message << "\nTo proceed, type \"#{app_to_confirm}\" or re-run this command with --confirm #{app_to_confirm}"
+        output_with_bang(message)
+        display
+        display "> ", false
+        if ask.downcase != app_to_confirm
+          error("Confirmation did not match #{app_to_confirm}. Aborted.")
+        else
+          true
+        end
+      end
+    end
+    
+    def format_error(error, message='Pebblescape client internal error.')
+      formatted_error = []
+      formatted_error << " !    #{message}"
+      formatted_error << ''
+      formatted_error << "    Error:       #{error.message} (#{error.class})"
+      command = ARGV.map do |arg|
+        if arg.include?(' ')
+          arg = %{"#{arg}"}
+        else
+          arg
+        end
+      end.join(' ')
+      formatted_error << "    Command:     pebbles #{command}"
+      require 'pebbles/auth'
+      unless Pebbles::Auth.host == Pebbles::Auth.default_host
+        formatted_error << "    Host:        #{Pebbles::Auth.host}"
+      end
+      if http_proxy = ENV['http_proxy'] || ENV['HTTP_PROXY']
+        formatted_error << "    HTTP Proxy:  #{http_proxy}"
+      end
+      if https_proxy = ENV['https_proxy'] || ENV['HTTPS_PROXY']
+        formatted_error << "    HTTPS Proxy: #{https_proxy}"
+      end
+      formatted_error << "    Version:     #{Pebbles.user_agent}"
+      formatted_error << "\n"
+      formatted_error.join("\n")
+    end
+    
+    def styled_header(header)
+      display("=== #{header}")
+    end
+    
+    # produces a printf formatter line for an array of items
+    # if an individual line item is an array, it will create columns
+    # that are lined-up
+    #
+    # line_formatter(["foo", "barbaz"])                 # => "%-6s"
+    # line_formatter(["foo", "barbaz"], ["bar", "qux"]) # => "%-3s   %-6s"
+    #
+    def line_formatter(array)
+      if array.any? {|item| item.is_a?(Array)}
+        cols = []
+        array.each do |item|
+          if item.is_a?(Array)
+            item.each_with_index { |val,idx| cols[idx] = [cols[idx]||0, (val || '').length].max }
+          end
+        end
+        cols.map { |col| "%-#{col}s" }.join("  ")
+      else
+        "%s"
+      end
+    end
+
+    def styled_array(array, options={})
+      fmt = line_formatter(array)
+      array = array.sort unless options[:sort] == false
+      array.each do |element|
+        display((fmt % element).rstrip)
+      end
+      display
+    end
+    
+    def styled_hash(hash, keys=nil)
+      max_key_length = hash.keys.map {|key| key.to_s.length}.max + 2
+      keys ||= hash.keys.sort {|x,y| x.to_s <=> y.to_s}
+      keys.each do |key|
+        case value = hash[key]
+        when Array
+          if value.empty?
+            next
+          else
+            elements = value.sort {|x,y| x.to_s <=> y.to_s}
+            display("#{key}: ".ljust(max_key_length), false)
+            display(elements[0])
+            elements[1..-1].each do |element|
+              display("#{' ' * max_key_length}#{element}")
+            end
+            if elements.length > 1
+              display
+            end
+          end
+        when nil
+          next
+        else
+          display("#{key}: ".ljust(max_key_length), false)
+          display(value)
+        end
+      end
+    end
+    
+    def flatten_hash(hash, key)
+      hash[key].each do |k, v|
+        hash["#{key}_#{k}"] = v
+      end
+      
+      hash.delete(key)
+    end
+    
+    def styled_error(error, message='Pebblescape client internal error.')
+      if Pebbles::Helpers.error_with_failure
+        display("failed")
+        Pebbles::Helpers.error_with_failure = false
+      end
+      $stderr.puts(format_error(error, message))
+    end
+    
+    def has_http_git_entry_in_netrc
+      Auth.netrc && Auth.netrc[Auth.http_git_host]
+    end
+  end
+end