pi 0.1.13

data/lib/cli/config.rb

@@ -0,0 +1,96 @@
+require "yaml"
+require 'fileutils'
+
+require 'rubygems'
+require 'json/pure'
+
+module PI::Cli
+  class Config
+
+    DEFAULT_TARGET  = 'api.staging.samsungcloud.org'
+    DEFAULT_SUGGEST = 'samsungcloud.org'
+
+    TARGET_FILE    = '~/.pi_target'
+    TOKEN_FILE     = '~/.pi_token'
+
+    class << self
+      attr_accessor :colorize
+      attr_accessor :output
+      attr_accessor :trace
+      attr_reader   :suggest_url
+
+      def target_url
+        target_file = File.expand_path(TARGET_FILE)
+        if File.exists? target_file
+          @target_url = lock_and_read(target_file).strip!
+          ha = @target_url.split('//')
+          ha.shift
+          @suggest_url = ha.join('.')
+          @suggest_url = DEFAULT_SUGGEST if @suggest_url.empty?
+        else
+          @target_url  = DEFAULT_TARGET
+          @suggest_url = DEFAULT_SUGGEST
+        end
+        @target_url = "http://#{@target_url}" unless /^https?/ =~ @target_url
+        @target_url = @target_url.gsub(/\/+$/, '')
+        @target_url
+      end
+
+      def store_target(target_host)
+        target_file = File.expand_path(TARGET_FILE)
+        lock_and_write(target_file, target_host)
+      end
+
+      def all_tokens
+        token_file = File.expand_path(TOKEN_FILE)
+        return nil unless File.exists? token_file
+        contents = lock_and_read(token_file).strip
+        JSON.parse(contents)
+      end
+
+      alias :targets :all_tokens
+
+      def auth_token
+        return @token if @token
+        tokens = all_tokens
+        @token = tokens[target_url] if tokens
+      end
+
+      def remove_token_file
+        FileUtils.rm_f(File.expand_path(TOKEN_FILE))
+      end
+
+      def store_token(token)
+        tokens = all_tokens || {}
+        tokens[target_url] = token
+        token_file = File.expand_path(TOKEN_FILE)
+        lock_and_write(token_file, tokens.to_json)
+      end
+
+      def lock_and_read(file)
+        File.open(file, "r") {|f|
+          f.flock(File::LOCK_EX)
+          contents = f.read
+          f.flock(File::LOCK_UN)
+          contents
+        }
+      end
+
+      def lock_and_write(file, contents)
+        File.open(file, File::RDWR | File::CREAT, 0600) {|f|
+          f.flock(File::LOCK_EX)
+          f.rewind
+          f.puts contents
+          f.flush
+          f.truncate(f.pos)
+          f.flock(File::LOCK_UN)
+        }
+      end
+    end
+
+    def initialize(work_dir = Dir.pwd)
+      @work_dir = work_dir
+    end
+
+  end
+end

data/lib/cli/core_ext.rb

@@ -0,0 +1,118 @@
+module PIExtensions
+
+  def say(message)
+    PI::Cli::Config.output.puts(message) if PI::Cli::Config.output
+  end
+
+  def header(message, filler = '-')
+    say "\n"
+    say message
+    say filler.to_s * message.size
+  end
+
+  def banner(message)
+    say "\n"
+    say message
+  end
+
+  def display(message, nl=true)
+    if nl
+      say message
+    else
+      if PI::Cli::Config.output
+        PI::Cli::Config.output.print(message)
+        PI::Cli::Config.output.flush
+      end
+    end
+  end
+
+  def clear(size=80)
+    return unless PI::Cli::Config.output
+    PI::Cli::Config.output.print("\r")
+    PI::Cli::Config.output.print(" " * size)
+    PI::Cli::Config.output.print("\r")
+  end
+
+  def err(message, prefix='Error: ')
+    raise PI::Cli::CliExit, "#{prefix}#{message}"
+  end
+
+  def quit(message = nil)
+    raise PI::Cli::GracefulExit, message
+  end
+
+  def blank?
+    self.to_s.blank?
+  end
+
+  def uptime_string(delta)
+    num_seconds = delta.to_i
+    days = num_seconds / (60 * 60 * 24);
+    num_seconds -= days * (60 * 60 * 24);
+    hours = num_seconds / (60 * 60);
+    num_seconds -= hours * (60 * 60);
+    minutes = num_seconds / 60;
+    num_seconds -= minutes * 60;
+    "#{days}d:#{hours}h:#{minutes}m:#{num_seconds}s"
+  end
+
+  def pretty_size(size, prec=1)
+    return 'NA' unless size
+    return "#{size}B" if size < 1024
+    return sprintf("%.#{prec}fK", size/1024.0) if size < (1024*1024)
+    return sprintf("%.#{prec}fM", size/(1024.0*1024.0)) if size < (1024*1024*1024)
+    return sprintf("%.#{prec}fG", size/(1024.0*1024.0*1024.0))
+  end
+
+end
+
+module PIStringExtensions
+
+  def red
+    colorize("\e[0m\e[31m")
+  end
+
+  def green
+    colorize("\e[0m\e[32m")
+  end
+
+  def yellow
+    colorize("\e[0m\e[33m")
+  end
+
+  def bold
+    colorize("\e[0m\e[1m")
+  end
+
+  def colorize(color_code)
+    if PI::Cli::Config.colorize
+      "#{color_code}#{self}\e[0m"
+    else
+      self
+    end
+  end
+
+  def blank?
+    self =~ /^\s*$/
+  end
+
+  def truncate(limit = 30)
+    return "" if self.blank?
+    etc = "..."
+    stripped = self.strip[0..limit]
+    if stripped.length > limit
+      stripped.gsub(/\s+?(\S+)?$/, "") + etc
+    else
+      stripped
+    end
+  end
+
+end
+
+class Object
+  include PIExtensions
+end
+
+class String
+  include PIStringExtensions
+end

data/lib/cli/errors.rb

@@ -0,0 +1,19 @@
+module PI::Cli
+
+  class CliError < StandardError
+    def self.error_code(code = nil)
+      define_method(:error_code) { code }
+    end
+  end
+
+  class UnknownCommand       < CliError; error_code(100); end
+  class TargetMissing        < CliError; error_code(102); end
+  class TargetInaccessible   < CliError; error_code(103); end
+
+  class TargetError          < CliError; error_code(201); end
+  class AuthError            < TargetError; error_code(202); end
+
+  class CliExit              < CliError; error_code(400); end
+  class GracefulExit         < CliExit;  error_code(401); end
+
+end

data/lib/cli/runner.rb

@@ -0,0 +1,269 @@
+require 'optparse'
+
+require File.dirname(__FILE__) + '/usage'
+
+class PI::Cli::Runner
+
+  attr_reader   :namespace
+  attr_reader   :action
+  attr_reader   :args
+  attr_reader   :options
+
+  def self.run(args)
+    new(args).run
+  end
+
+  def initialize(args=[])
+    @args = args
+    @options = { :colorize => true }
+    @exit_status = true
+  end
+
+  # Collect all the available options for all commands
+  # Some duplicates exists to capture all scenarios
+  def parse_options!
+    opts_parser = OptionParser.new do |opts|
+      opts.banner = "\nAvailable options:\n\n"
+      # generic tracing and debugging
+      opts.on('-t [TKEY]')         { |tkey|  @options[:trace] = tkey || true }
+      opts.on('--trace [TKEY]')    { |tkey|  @options[:trace] = tkey || true }
+      opts.on('-q', '--quiet')     {         @options[:quiet] = true }
+      opts.on('--verbose')         {         @options[:verbose] = true }
+      opts.on('--json')            {         @options[:json] = true }
+      opts.on('-v', '--version')   {         set_cmd(:misc, :version) }
+      opts.on('-h', '--help')      {         puts "#{command_usage}\n"; exit }
+      opts.on_tail('--options')    {         puts "#{opts}\n"; exit }
+    end
+    instances_delta_arg = check_instances_delta!
+    @args = opts_parser.parse!(@args)
+    @args.concat instances_delta_arg
+    self
+  end
+
+  def check_instances_delta!
+    return unless @args
+    instance_args = @args.select { |arg| /^[-]\d+$/ =~ arg } || []
+    @args.delete_if { |arg| instance_args.include? arg}
+    instance_args
+  end
+
+  def display_help
+    puts command_usage
+    exit
+  end
+
+  def set_cmd(namespace, action, args_range=0)
+    return if @help_only
+    unless args_range == "*" || args_range.is_a?(Range)
+      args_range = (args_range.to_i..args_range.to_i)
+    end
+
+    if args_range == "*" || args_range.include?(@args.size)
+      @namespace = namespace
+      @action    = action
+    else
+      @exit_status = false
+      if @args.size > args_range.last
+        usage_error("Too many arguments for [#{action}]: %s" % [ @args[args_range.last..-1].map{|a| "'#{a}'"}.join(', ') ])
+      else
+        usage_error("Not enough arguments for [#{action}]")
+      end
+    end
+  end
+
+  def parse_command!
+    # just return if already set, happends with -v, -h
+    return if @namespace && @action
+
+    verb = @args.shift
+    case verb
+      
+    ###############################################################################
+    # Users
+    ###############################################################################
+    
+    when 'login'
+      usage('pi login [url]')
+      set_cmd(:user, :login, @args.size == 1 ? 1 : 0)
+      
+    when 'logout'
+      usage('pi logout')
+      set_cmd(:user, :logout)
+      
+    when 'info'
+      usage ('pi info')
+      set_cmd(:user, :info)
+      
+    when 'user'
+      usage ('pi user')
+      set_cmd(:user, :user)
+      
+    when 'targets'
+      usage ('pi targets')
+      set_cmd(:user, :targets)
+      
+    when 'password'
+      usage ('pi password [newpassword]')
+      set_cmd(:user, :password, @args.size == 1 ? 1 : 0)
+      
+    when 'github'
+      usage ('pi github ')
+      set_cmd(:user, :github)
+      
+    when 'runtimes'
+      usage('pi runtimes')
+      set_cmd(:user, :runtimes)
+
+    when 'frameworks'
+      usage('pi frameworks')
+      set_cmd(:user, :frameworks)
+      
+    when 'version', 'v'
+      usage('pi version')
+      set_cmd(:misc, :version)
+      
+    when 'help'
+      display_help if @args.size == 0
+      @help_only = true
+      parse_command!
+      
+    when 'options'
+      @args = @args.unshift('--options')
+      parse_options!
+    
+    ###############################################################################
+    # Projects
+    ###############################################################################
+    
+    when 'projects'
+      usage('pi projects')
+      set_cmd(:projects, :projects)
+      
+    when 'create-project'
+      usage('pi create-project [projectname]')
+      set_cmd(:projects, :create_project, @args.size == 1 ? 1 : 0) 
+  
+    when 'delete-project'
+      usage('pi delete-project [projectname]')
+      set_cmd(:projects, :delete_project, @args.size == 1 ? 1 : 0) 
+      
+    when 'upload'
+      usage('pi upload [projectname]')
+      set_cmd(:projects, :upload, @args.size == 1 ? 1 : 0)
+      
+    when 'project-events' 
+      usage('pi project-events [projectname]')
+      set_cmd(:projects, :project_events, @args.size == 1 ? 1 : 0) 
+        
+    when 'project-tags'
+      usage('pi project-tags [projectname]')
+      set_cmd(:projects, :project_tags, @args.size == 1 ? 1 : 0) 
+    
+    when 'project-commits'
+      usage('pi project-commits [projectname]')
+      set_cmd(:projects, :project_commits, @args.size == 1 ? 1 : 0) 
+    
+    when 'project-apps'
+      usage('pi project-apps [projectname]')
+      set_cmd(:projects, :project_apps, @args.size == 1 ? 1 : 0)
+      
+    when 'usage'
+      display basic_usage
+      exit(true)
+
+    else
+      if verb
+        display "pi: Unknown command [#{verb}]"
+        display basic_usage
+        exit(false)
+      end
+    end
+  end
+
+  def usage(msg = nil)
+    @usage = msg if msg
+    @usage
+  end
+
+  def usage_error(msg = nil)
+    @usage_error = msg if msg
+    @usage_error
+  end
+
+  def run
+
+    trap('TERM') { print "\nTerminated\n"; exit(false)}
+
+    parse_options!
+
+    @options[:colorize] = false unless STDOUT.tty?
+
+    PI::Cli::Config.colorize   = @options.delete(:colorize)
+    PI::Cli::Config.trace      = @options.delete(:trace)
+    PI::Cli::Config.output   ||= STDOUT unless @options[:quiet]
+
+    parse_command!
+    if @namespace && @action
+      eval("PI::Cli::Command::#{@namespace.to_s.capitalize}").new(@options).send(@action.to_sym, *@args)
+    elsif @help_only || @usage
+      display_usage
+    else
+      display basic_usage
+      exit(false)
+    end
+
+  rescue OptionParser::InvalidOption => e
+  rescue OptionParser::AmbiguousOption => e
+    puts(e.message.red)
+    puts("\n")
+    puts(basic_usage)
+    @exit_status = false
+  rescue PI::Client::AuthError => e
+    if PI::Cli::Config.auth_token.nil?
+      puts "Login Required".red
+    else
+      puts "Not Authorized".red
+    end
+    @exit_status = false
+  rescue PI::Client::TargetError, PI::Client::NotFound, PI::Client::BadTarget  => e
+    puts e.message.red
+    @exit_status = false
+  rescue PI::Client::HTTPException => e
+    puts e.message.red
+    @exit_status = false
+  rescue PI::Cli::GracefulExit => e
+    # Redirected commands end up generating this exception (kind of goto)
+  rescue PI::Cli::CliExit => e
+    puts e.message.red
+    @exit_status = false
+  rescue PI::Cli::CliError => e
+    say("Error #{e.error_code}: #{e.message}".red)
+    @exit_status = false
+  rescue SystemExit => e
+    @exit_status = e.success?
+  rescue SyntaxError => e
+    puts e.message.red
+    puts e.backtrace
+    @exit_status = false
+  rescue Interrupt => e
+    say("\nInterrupted".red)
+    @exit_status = false
+  rescue => e
+    puts e.message.red
+    puts e.backtrace
+    @exit_status = false
+  ensure
+    say("\n")
+    @exit_status == true if @exit_status.nil?
+    if @options[:verbose]
+      if @exit_status
+        puts "[#{@namespace}:#{@action}] SUCCEEDED".green
+      else
+        puts "[#{@namespace}:#{@action}] FAILED".red
+      end
+      say("\n")
+    end
+    exit(@exit_status)
+  end
+
+end