pi 0.1.23 → 0.1.24

data/lib/cli/commands/services.rb

@@ -1,37 +1,12 @@
-require "interact"
 module PI::Cli::Command
   class Services < Base
     include PI::Cli::ChooseHelper  
-    include Interactive
+    include PI::Cli::InteractHelper 
     
-    def usable_services(appname=nil)
-      unless appname         
-        useproject = choose_project
-        projectid = useproject[:id]
-        useapp = choose_app(projectid)
-        appname = useapp[:name]
-      end
-      services = client.usable_services(appname)
-      return display JSON.pretty_generate(services) if @options[:json]
-      return display "No Services" if services.nil? || services.empty?
-      services.sort! {|a, b| a[:name] <=> b[:name] }
-      services_table = table do |t|
-        t.headings = 'Name', 'Version', 'Type'
-        services.each do |s|
-          t << [s[:name], s[:version] ,s[:service_type]]
-        end
-      end
-      display services_table
-    end
-    
-    def app_service(appname=nil)
-      unless appname         
-        useproject = choose_project
-        projectid = useproject[:id]
-        useapp = choose_app(projectid)
-        appname = useapp[:name]
-      end
-      services = client.app_service(appname)
+    def app_service(appid_or_appname=nil)
+      client.check_login_status
+      app = choose_app_help_target_not_all(appid_or_appname)
+      services = client.app_service(app[:id])
       return display JSON.pretty_generate(services) if @options[:json]
       return display "No Services" if services.nil? || services.empty?
       services.sort! {|a, b| a[:name] <=> b[:name] }
@@ -44,17 +19,10 @@ module PI::Cli::Command
       display services_table
     end  
     
-    def bind_service(appname=nil)
-      unless appname         
-        useproject = choose_project
-        projectid = useproject[:id]
-        useapp = choose_app(projectid)
-        appname = useapp[:name]
-      end
-      app  = client.app_get_byname(appname)
-      err "The application is not found! App name :#{appname}" unless (appname == app[:name] ? true : false)      
-
-      services = client.usable_services(appname)
+    def bind_service(appid_or_appname=nil)
+      client.check_login_status
+      app = choose_app_help_target_not_all(appid_or_appname)
+      services = client.usable_services(app[:id])
       err "No usable services!" if services.nil? || services.empty?
       
       choices = Array.new
@@ -62,10 +30,12 @@ module PI::Cli::Command
         choices << s[:name]
       end 
            
-      manifest = ask "Select services, indexed list?", :choices => choices, :indexed => true
-      manifest = manifest.to_a
+      manifest = asks "Select services, indexed list?", :choices => choices, :indexed => true
       display "Selected services: ",false
-      display "#{manifest}"  
+      manifest.each do |m|
+        display "#{m} ",false
+      end 
+      display "\n"  
       display "Binding service: ",false
       
       t = Thread.new do     
@@ -76,55 +46,60 @@ module PI::Cli::Command
       end
       end
       
-      client.bind_service(appname,manifest)
-      result = check_status(app[:name], "bindservice")
+      client.bind_service(app[:id],manifest)
+      result = check_status(app[:targetName], app[:name], "bindservice")
       Thread.kill(t)
-      if result[:code] == 200
-        display "OK".green   
+      if result[:code] == 200 
+        if not result[:text].empty?
+          display "OK".green
+        else
+          display "Please try again"
+        end            
       else
         err result[:text]   
       end
     end  
     
-    def unbind_service(appname=nil)
-       unless appname         
-        useproject = choose_project
-        projectid = useproject[:id]
-        useapp = choose_app(projectid)
-        appname = useapp[:name]
-      end
-      app  = client.app_get_byname(appname)
-      err "The application is not found! App name :#{appname}" unless (appname == app[:name] ? true : false)      
-      services = client.app_service(appname)
-      err "No binded services!" if services.nil? || services.empty?
-      
-      useservice = nil
-      choose do |menu|
-        display "=============Services============"
-        menu.prompt = "Select Service: "
-        menu.select_by = :index_or_name
-        services.each do |service|
-          menu.choice("#{service[:name]}") { useservice = service }
-        end
-      end
-      display "Selected Service: ",false
-      display "#{useservice[:name]}"  
-      manifest = [useservice[:name]] 
-      display "Unbinding service: ",false
-      
+    def unbind_service(appid_or_appname=nil)
+      client.check_login_status
+      app = choose_app_help_target_not_all(appid_or_appname)
+      services = client.app_service(app[:id])
+      err "No binded services!" if services.nil? || services.empty?      
+      service_choices = Array.new
+      services.each do |s|
+        service_choices << s[:name]
+      end      
+      services = asks "Select Service", :choices => service_choices, :indexed => true
+      display "Selected DNS: ",false
+      services.each do |m|
+        display "#{m} ",false
+      end 
+      display "\n"
+      services.each do |service|
+        do_unbind_service(app, service)
+      end  
+    end
+    
+    private
+    
+    def do_unbind_service(app, service)
+      display "Unbinding service '#{service}': ",false     
       t = Thread.new do     
       loop do
         display '.', false 
         sleep (1)
         break unless t.alive?
       end
-      end
-      
-      client.unbind_service(appname,manifest)
-      result = check_status(app[:name], "unbindservice")
+      end      
+      client.unbind_service(app[:id], service)
+      result = check_status(app[:targetName], app[:name], "unbindservice")
       Thread.kill(t)
-      if result[:code] == 200
-        display "OK".green   
+      if result[:code] == 200 
+        if not result[:text].empty?
+          display "OK".green
+        else
+          display "Please try again"
+        end            
       else
         err result[:text]   
       end

data/lib/cli/commands/user.rb

@@ -3,8 +3,12 @@ require 'set'
 module PI::Cli::Command
 
   class User < Base
-       
+    YES_SET = Set.new(["y", "Y", "yes", "YES"])   
+    NO_SET = Set.new(["n", "N", "no", "NO"])
+    
     def login(url=nil)
+      user = @options[:user]
+      password = @options[:password]
       unless url
         url = ask "Attempting login to '#{target_url}'?", :default => true
         if url == true
@@ -14,12 +18,16 @@ module PI::Cli::Command
         end
       end      
       url = "#{target_url}" if url.nil? || url.empty?
-      eval("PI::Cli::Command::Misc").new().send("set_target", url)     
+      eval("PI::Cli::Command::Misc").new().send("set_target", url)
+      unless client.target_valid?        
+        display "Host is not available or is not valid: '#{target_url}'".red
+        display "\n<<<\n#{client.raw_info}\n>>>\n"             
+        exit(false)    
+      end
+         
       tries ||= 0
-      user = ask "User"
-      password = ask "Password", :echo => '*'
-      err "Need a valid user" unless user
-      err "Need a password" unless password
+      user = ask "User" unless user
+      password = ask "Password", :echo => '*' unless password
       login_and_save_token(user, password)
       say "Successfully logged into [#{target_url}]".green
     rescue PI::Client::TargetError
@@ -27,7 +35,7 @@ module PI::Cli::Command
       retry if (tries += 1) < 3 && !@options[:passwd]
       exit 1
     rescue => e
-      display "Problem with login, #{e}, try again or register for an account.".red
+      display "Problem with login, #{e}, try again.".red
       exit 1
     end
     
@@ -46,6 +54,7 @@ module PI::Cli::Command
     end
     
     def user
+      client.check_login_status
       user = client.user_info
       github_info = client.github_info
       github_info[:name] = "null" if github_info[:name].empty? || github_info[:name].nil?
@@ -62,6 +71,7 @@ module PI::Cli::Command
     end
     
     def targets
+      client.check_login_status
       targets = client.targets
       return display JSON.pretty_generate(targets) if @options[:json]
       return display 'No Targets' if targets.empty?
@@ -75,7 +85,8 @@ module PI::Cli::Command
       display targets_table
     end
 
-    def password(newpassword=nil)      
+    def password(newpassword=nil)   
+      client.check_login_status   
       unless newpassword
         loop{
         newpassword = ask "New Password", :echo => '*'
@@ -94,9 +105,12 @@ module PI::Cli::Command
     end
     
     def github(name=nil)
+      client.check_login_status
+      email = @options[:email]
+      password = @options[:password]      
       name = ask "Please input your name" unless name
-      email = ask "Please input your email" 
-      password = ask "Please input your password", :echo => '*'
+      email = ask "Please input your email" unless email
+      password = ask "Please input your password", :echo => '*' unless password
       manifest = {
         :name => "#{name}",
         :password     => "#{password}",
@@ -108,6 +122,7 @@ module PI::Cli::Command
     end
     
     def runtimes
+      client.check_login_status
       runtimes_info = client.runtimes
       return display JSON.pretty_generate(runtimes_info) if @options[:json]
       return display "No Runtimes" if runtimes_info.empty?
@@ -120,6 +135,7 @@ module PI::Cli::Command
     end
 
     def frameworks
+      client.check_login_status
       runtimes = client.runtimes
       java_runtime = runtimes[0].downcase
       ruby_runtime = runtimes[1].downcase

data/lib/cli/interact_helper.rb

@@ -0,0 +1,538 @@
+module PI::Cli
+  module InteractHelper
+  EVENTS = {
+    "\b" => :backspace,
+    "\t" => :tab,
+    "\x01" => :home,
+    "\x03" => :interrupt,
+    "\x04" => :eof,
+    "\x05" => :end,
+    "\x17" => :kill_word,
+    "\x7f" => :backspace,
+    "\r" => :enter,
+    "\n" => :enter
+  }
+
+  ESCAPES = {
+    "[A" => :up, "H" => :up,
+    "[B" => :down, "P" => :down,
+    "[C" => :right, "M" => :right,
+    "[D" => :left, "K" => :left,
+    "[3~" => :delete, "S" => :delete,
+    "[H" => :home, "G" => :home,
+    "[F" => :end, "O" => :end,
+    "[Z" => :shift_tab
+  }
+
+  class InputState
+    attr_accessor :options, :answer, :position
+
+    def initialize(options = {}, answer = "", position = 0)
+      @options = options
+      @answer = answer
+      @position = position
+      @done = false
+    end
+
+    # Call to signal to the input reader that it can stop.
+    def done!
+      @done = true
+    end
+
+    # Is the input finished/complete?
+    def done?
+      @done
+    end
+
+    def censor(what)
+      if with = @options[:echo]
+        with * what.size
+      else
+        what
+      end
+    end
+
+    def display(what)
+      print(censor(what))
+      @position += what.size
+    end
+
+    def back(x)
+      return if x == 0
+
+      print("\b" * (x * char_size))
+
+      @position -= x
+    end
+
+    def clear(x)
+      return if x == 0
+
+      print(" " * (x * char_size))
+
+      @position += x
+
+      back(x)
+    end
+
+    def goto(pos)
+      return if pos == position
+
+      if pos > position
+        display(answer[position .. pos])
+      else
+        print("\b" * (position - pos) * char_size)
+      end
+
+      @position = pos
+    end
+
+    private
+
+    def char_size
+      @options[:echo] ? @options[:echo].size : 1
+    end
+  end
+
+  def read_char(options = {})
+    input = options[:input] || $stdin
+
+    with_char_io(input) do
+      get_character(input)
+    end
+  end
+
+  def read_event(options = {})
+    input = options[:input] || $stdin
+
+    with_char_io(input) do
+      get_event(input)
+    end
+  end
+
+  def read_line(options = {})
+    input = options[:input] || $stdin
+
+    state = input_state(options)
+    with_char_io(input) do
+      until state.done?
+        handler(get_event(input), state)
+      end
+    end
+
+    state.answer
+  end
+
+  def asks(question, options = {})
+    choices = options[:choices] && options[:choices].to_a
+
+    list_choices(choices, options) if choices
+
+    while true
+      prompt(question, options)
+      ok, res = new_answered(read_line(options), options)
+      return res if ok
+    end
+  end
+
+  private
+
+  def clear_input(state)
+    state.goto(0)
+    state.clear(state.answer.size)
+    state.answer = ""
+  end
+
+  def set_input(state, input)
+    clear_input(state)
+    state.display(input)
+    state.answer = input
+  end
+
+  def redraw_input(state)
+    pos = state.position
+    state.goto(0)
+    state.display(state.answer)
+    state.goto(pos)
+  end
+
+  def input_state(options)
+    InputState.new(options)
+  end
+
+  def get_event(input)
+    escaped = false
+    escape_seq = ""
+
+    while true
+      c = get_character(input)
+
+      if not c
+        return :eof
+      elsif c == "\e" || c == "\xE0"
+        escaped = true
+      elsif escaped
+        escape_seq << c
+
+        if cmd = ESCAPES[escape_seq]
+          return cmd
+        elsif ESCAPES.select { |k, v|
+                k.start_with? escape_seq
+              }.empty?
+          escaped, escape_seq = false, ""
+        end
+      elsif EVENTS.key? c
+        return EVENTS[c]
+      elsif c < " "
+        # ignore
+      else
+        return [:key, c]
+      end
+    end
+  end
+
+  def new_answered(ans, options)
+    print "\n"
+
+    if ans.empty?
+      if options.key?(:default)
+        [true, options[:default]]
+      end
+    elsif choices = options[:choices]
+      matches = choices.select { |x|
+        choice_completion(x, options).start_with? ans
+      }
+
+      if choices and ans =~ /^\s*\d+\s*$/ and \
+          ans.to_i - 1 >= 0 and res = choices.to_a[ans.to_i - 1]
+          res = Array.new
+          res = res.push(choices.to_a[ans.to_i - 1])
+        [true, res]
+        #add
+      elsif choices and ans =~ /^\s*(\d+,)*\d+\s*$/ and \
+          ans.to_i - 1 >= 0 
+          ans = ans.split(",")
+          res = Array.new
+          ans.each do |a|
+            res.push(choices[a.to_i - 1])
+          end 
+          # res =  ["rails.samsungpaas.comrailstest.samsungpaas.com"]
+        [true, res]    
+        #add    
+      elsif matches.size == 1
+        [true, matches.first]
+      elsif matches.size > 1
+        matches_list = matches.collect { |m|
+          show_choice(m, options)
+        }.join " or "
+
+        puts "Please disambiguate: #{matches_list}?"
+
+        [false, nil]
+      else
+        puts "Unknown answer, please try again!"
+        [false, nil]
+      end
+    else
+      [true, match_type(ans, options[:default])]
+    end
+  end
+
+  def list_choices(choices, options = {})
+    return unless options[:indexed]
+
+    choices.each_with_index do |o, i|
+      puts "#{i + 1}: #{show_choice(o, options)}"
+    end
+  end
+
+  def show_choice(choice, options = {})
+    display = options[:display] || proc(&:to_s)
+    display.call(choice)
+  end
+
+  def choice_completion(choice, options = {})
+    complete = options[:complete] || options[:display] || proc(&:to_s)
+    complete.call(choice)
+  end
+
+  def common_prefix(*strs)
+    return strs.first.dup if strs.size == 1
+
+    longest = strs.sort_by(&:size).last
+    longest.size.times do |i|
+      sub = longest[0..(-1 - i)]
+      if strs.all? { |s| s.start_with?(sub) }
+        return sub
+      end
+    end
+
+    ""
+  end
+
+  def handler(which, state)
+    ans = state.answer
+    pos = state.position
+
+    case which
+    when :up
+      # nothing
+
+    when :down
+      # nothing
+
+    when :tab
+      matches =
+        if choices = state.options[:choices]
+          choices.collect { |c|
+            choice_completion(c, state.options)
+          }.select { |c|
+            c.start_with? ans
+          }
+        else
+          matching_paths(ans)
+        end
+
+      if matches.empty?
+        print("\a") # bell
+      else
+        old = ans
+        ans = state.answer = common_prefix(*matches)
+        state.display(ans[pos .. -1])
+        print("\a") if ans == old
+      end
+
+    when :right
+      unless pos == ans.size
+        state.display(ans[pos .. pos])
+      end
+
+    when :left
+      unless pos == 0
+        state.back(1)
+      end
+
+    when :delete
+      unless pos == ans.size
+        ans.slice!(pos, 1)
+        rest = ans[pos .. -1]
+        state.display(rest)
+        state.clear(1)
+        state.back(rest.size)
+      end
+
+    when :home
+      state.goto(0)
+
+    when :end
+      state.goto(ans.size)
+
+    when :backspace
+      if pos > 0
+        rest = ans[pos .. -1]
+
+        ans.slice!(pos - 1, 1)
+
+        state.back(1)
+        state.display(rest)
+        state.clear(1)
+        state.back(rest.size)
+      end
+
+    when :interrupt
+      raise Interrupt.new
+
+    when :eof
+      state.done! if ans.empty?
+
+    when :kill_word
+      if pos > 0
+        start = /[[:alnum:]]*\s*[^[:alnum:]]?$/ =~ ans[0 .. (pos - 1)]
+
+        if pos < ans.size
+          to_end = ans.size - pos
+          rest = ans[pos .. -1]
+          state.clear(to_end)
+        end
+
+        length = pos - start
+
+        ans.slice!(start, length)
+        state.back(length)
+        state.clear(length)
+
+        if to_end
+          state.display(rest)
+          state.back(to_end)
+        end
+      end
+
+    when :enter
+      state.done!
+
+    when Array
+      case which[0]
+      when :key
+        c = which[1]
+        rest = ans[pos .. -1]
+
+        ans.insert(pos, c)
+
+        state.display(c + rest)
+        state.back(rest.size)
+      end
+
+    else
+      return false
+    end
+
+    true
+  end
+
+  def matching_paths(input)
+    home = File.expand_path("~")
+
+    Dir.glob(input.sub("~", home) + "*").collect do |p|
+      p.sub(home, "~")
+    end
+  end
+
+  def prompt(question, options = {})
+    print question
+
+    if (choices = options[:choices]) && !options[:indexed]
+      print " (#{choices.collect(&:to_s).join ", "})"
+    end
+
+    case options[:default]
+    when true
+      print " [Yn]"
+    when false
+      print " [yN]"
+    when nil
+    else
+      print " [#{options[:default]}]"
+    end
+
+    print ": "
+  end
+
+  def match_type(str, x)
+    case x
+    when Integer
+      str.to_i
+    when true, false
+      str.upcase.start_with? "Y"
+    else
+      str
+    end
+  end
+
+  def with_char_io(input)
+    before = set_input_state(input)
+    yield
+  ensure
+    restore_input_state(input, before)
+  end
+
+  def chr(x)
+    x && x.chr
+  end
+
+  private :chr
+
+  # Definitions for reading character-by-character with no echoing.
+  begin
+    require "Win32API"
+
+    def set_input_state(input)
+      nil
+    end
+
+    def restore_input_state(input, state)
+      nil
+    end
+
+    def get_character(input)
+      if input == STDIN
+        begin
+          chr(Win32API.new("msvcrt", "_getch", [], "L").call)
+        rescue
+          chr(Win32API.new("crtdll", "_getch", [], "L").call)
+        end
+      else
+        chr(input.getc)
+      end
+    end
+  rescue LoadError
+    begin
+      require "termios"
+
+      def set_input_state(input)
+        return nil unless input.tty?
+        before = Termios.getattr(input)
+
+        new = before.dup
+        new.c_lflag &= ~(Termios::ECHO | Termios::ICANON)
+        new.c_cc[Termios::VMIN] = 1
+
+        Termios.setattr(input, Termios::TCSANOW, new)
+
+        before
+      end
+
+      def restore_input_state(input, before)
+        if before
+          Termios.setattr(input, Termios::TCSANOW, before)
+        end
+      end
+
+      def get_character(input)
+        chr(input.getc)
+      end
+    rescue LoadError
+      begin
+        require "ffi-ncurses"
+
+        def set_input_state(input)
+          return nil unless input.tty?
+
+          FFI::NCurses.initscr
+          FFI::NCurses.cbreak
+
+          true
+        end
+
+        def restore_input_state(input, before)
+          if before
+            FFI::NCurses.endwin
+          end
+        end
+
+        def get_character(input)
+          chr(input.getc)
+        end
+      rescue LoadError
+        def set_input_state(input)
+          return nil unless input.tty?
+
+          before = `stty -g`
+
+          Kernel.system("stty -echo -icanon isig")
+
+          before
+        end
+
+        def restore_input_state(input, before)
+          Kernel.system("stty #{before}") if before
+        end
+
+        def get_character(input)
+          chr(input.getc)
+        end
+      end
+    end
+  end
+  
+ end
+end