vmc_virgo 0.0.1.beta

data/lib/cli/config.rb

@@ -0,0 +1,160 @@
+require "yaml"
+require 'fileutils'
+
+require 'rubygems'
+require 'json/pure'
+
+module VMC::Cli
+  class Config
+
+    DEFAULT_TARGET  = 'api.vcap.me'
+
+    TARGET_FILE    = '~/.vmc_target'
+    TOKEN_FILE     = '~/.vmc_token'
+    INSTANCES_FILE = '~/.vmc_instances'
+    ALIASES_FILE   = '~/.vmc_aliases'
+    CLIENTS_FILE   = '~/.vmc_clients'
+
+    STOCK_CLIENTS = File.expand_path("../../../config/clients.yml", __FILE__)
+
+    class << self
+      attr_accessor :colorize
+      attr_accessor :output
+      attr_accessor :trace
+      attr_accessor :nozip
+
+      def target_url
+        return @target_url if @target_url
+        target_file = File.expand_path(TARGET_FILE)
+        if File.exists? target_file
+          @target_url = lock_and_read(target_file).strip
+        else
+          @target_url  = DEFAULT_TARGET
+        end
+        @target_url = "http://#{@target_url}" unless /^https?/ =~ @target_url
+        @target_url = @target_url.gsub(/\/+$/, '')
+        @target_url
+      end
+
+      def base_of(url)
+        url.sub(/^[^\.]+\./, "")
+      end
+
+      def suggest_url
+        @suggest_url ||= base_of(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_path=nil)
+        token_file = File.expand_path(token_file_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(token_file_path=nil)
+        return @token if @token
+        tokens = all_tokens(token_file_path)
+        @token = tokens[target_url] if tokens
+      end
+
+      def remove_token_file
+        FileUtils.rm_f(File.expand_path(TOKEN_FILE))
+      end
+
+      def store_token(token, token_file_path=nil)
+        tokens = all_tokens(token_file_path) || {}
+        tokens[target_url] = token
+        token_file = File.expand_path(token_file_path || TOKEN_FILE)
+        lock_and_write(token_file, tokens.to_json)
+      end
+
+      def instances
+        instances_file = File.expand_path(INSTANCES_FILE)
+        return nil unless File.exists? instances_file
+        contents = lock_and_read(instances_file).strip
+        JSON.parse(contents)
+      end
+
+      def store_instances(instances)
+        instances_file = File.expand_path(INSTANCES_FILE)
+        lock_and_write(instances_file, instances.to_json)
+      end
+
+      def aliases
+        aliases_file = File.expand_path(ALIASES_FILE)
+        # bacward compatible
+        unless File.exists? aliases_file
+          old_aliases_file = File.expand_path('~/.vmc-aliases')
+          FileUtils.mv(old_aliases_file, aliases_file) if File.exists? old_aliases_file
+        end
+        aliases = YAML.load_file(aliases_file) rescue {}
+      end
+
+      def store_aliases(aliases)
+        aliases_file = File.expand_path(ALIASES_FILE)
+        File.open(aliases_file, 'wb') {|f| f.write(aliases.to_yaml)}
+      end
+
+      def deep_merge(a, b)
+        merge = proc do |_, old, new|
+          if new.is_a?(Hash) and old.is_a?(Hash)
+            old.merge(new, &merge)
+          else
+            new
+          end
+        end
+
+        a.merge(b, &merge)
+      end
+
+      def clients
+        return @clients if @clients
+
+        stock = YAML.load_file(STOCK_CLIENTS)
+        clients = File.expand_path CLIENTS_FILE
+        if File.exists? clients
+          user = YAML.load_file(clients)
+          @clients = deep_merge(stock, user)
+        else
+          @clients = stock
+        end
+      end
+
+      def lock_and_read(file)
+        File.open(file, File::RDONLY) {|f|
+          if defined? JRUBY_VERSION
+            f.flock(File::LOCK_SH)
+          else
+            f.flock(File::LOCK_EX)
+          end
+          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/console_helper.rb

@@ -0,0 +1,157 @@
+require 'net/telnet'
+require 'readline'
+
+module VMC::Cli
+  module ConsoleHelper
+
+    def console_connection_info(appname)
+      app = client.app_info(appname)
+      fw = VMC::Cli::Framework.lookup_by_framework(app[:staging][:model])
+      if !fw.console
+        err "'#{appname}' is a #{fw.name} application.  " +
+          "Console access is not supported for #{fw.name} applications."
+      end
+      instances_info_envelope = client.app_instances(appname)
+      instances_info_envelope = {} if instances_info_envelope.is_a?(Array)
+
+      instances_info = instances_info_envelope[:instances] || []
+      err "No running instances for [#{appname}]" if instances_info.empty?
+
+      entry = instances_info[0]
+      if !entry[:console_port]
+        begin
+          client.app_files(appname, '/app/cf-rails-console')
+          err "Console port not provided for [#{appname}].  Try restarting the app."
+        rescue VMC::Client::TargetError, VMC::Client::NotFound
+          err "Console access not supported for [#{appname}]. " +
+            "Please redeploy your app to enable support."
+        end
+      end
+      conn_info = {'hostname' => entry[:console_ip], 'port' => entry[:console_port]}
+    end
+
+    def start_local_console(port, appname)
+      auth_info = console_credentials(appname)
+      display "Connecting to '#{appname}' console: ", false
+      prompt = console_login(auth_info, port)
+      display "OK".green
+      display "\n"
+      initialize_readline
+      run_console prompt
+    end
+
+    def console_login(auth_info, port)
+      if !auth_info["username"] || !auth_info["password"]
+        err "Unable to verify console credentials."
+      end
+      @telnet_client = telnet_client(port)
+      prompt = nil
+      err_msg = "Login attempt timed out."
+      5.times do
+        begin
+          results = @telnet_client.login("Name"=>auth_info["username"],
+            "Password"=>auth_info["password"]) {|line|
+            if line =~ /[$%#>] \z/n
+              prompt = line
+            elsif line =~ /Login failed/
+              err_msg = line
+            end
+          }
+          break
+        rescue TimeoutError
+          sleep 1
+        rescue EOFError
+          #This may happen if we login right after app starts
+          close_console
+          sleep 5
+          @telnet_client = telnet_client(port)
+        end
+        display ".", false
+      end
+      unless prompt
+        close_console
+        err err_msg
+      end
+      prompt
+    end
+
+    def send_console_command(cmd)
+      results = @telnet_client.cmd(cmd)
+      results.split("\n")
+    end
+
+    def console_credentials(appname)
+      content = client.app_files(appname, '/app/cf-rails-console/.consoleaccess', '0')
+      YAML.load(content)
+    end
+
+    def close_console
+      @telnet_client.close
+    end
+
+    def console_tab_completion_data(cmd)
+      begin
+        results = @telnet_client.cmd("String"=> cmd + "\t", "Match"=>/\S*\n$/, "Timeout"=>10)
+        results.chomp.split(",")
+      rescue TimeoutError
+        [] #Just return empty results if timeout occurred on tab completion
+      end
+    end
+
+    private
+    def telnet_client(port)
+      Net::Telnet.new({"Port"=>port, "Prompt"=>/[$%#>] \z|Login failed/n, "Timeout"=>30, "FailEOF"=>true})
+    end
+
+    def readline_with_history(prompt)
+      line = Readline.readline(prompt, true)
+      return '' if line.nil?
+      #Don't keep blank or repeat commands in history
+      if line =~ /^\s*$/ or Readline::HISTORY.to_a[-2] == line
+        Readline::HISTORY.pop
+      end
+      line
+    end
+
+    def run_console(prompt)
+      while(cmd = readline_with_history(prompt))
+        if(cmd == "exit" || cmd == "quit")
+          #TimeoutError expected, as exit doesn't return anything
+          @telnet_client.cmd("String"=>cmd,"Timeout"=>1) rescue TimeoutError
+          close_console
+          break
+        end
+        if !cmd.empty?
+          prompt = send_console_command_display_results(cmd, prompt)
+        end
+      end
+    end
+
+    def send_console_command_display_results(cmd, prompt)
+      begin
+        lines = send_console_command cmd
+        #Assumes the last line is a prompt
+        prompt = lines.pop
+        lines.each {|line| display line if line != cmd}
+      rescue TimeoutError
+        display "Timed out sending command to server.".red
+      rescue EOFError
+        err "The console connection has been terminated.  Perhaps the app was stopped or deleted?"
+      end
+      prompt
+    end
+
+    def initialize_readline
+      if Readline.respond_to?("basic_word_break_characters=")
+        Readline.basic_word_break_characters= " \t\n`><=;|&{("
+      end
+      Readline.completion_append_character = nil
+      #Assumes that sending a String ending with tab will return a non-empty
+      #String of comma-separated completion options, terminated by a new line
+      #For example, "app.\t" might result in "to_s,nil?,etc\n"
+      Readline.completion_proc = proc {|s|
+        console_tab_completion_data s
+      }
+    end
+  end
+end

data/lib/cli/core_ext.rb

@@ -0,0 +1,122 @@
+module VMCExtensions
+
+  def say(message)
+    VMC::Cli::Config.output.puts(message) if VMC::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 VMC::Cli::Config.output
+        VMC::Cli::Config.output.print(message)
+        VMC::Cli::Config.output.flush
+      end
+    end
+  end
+
+  def clear(size=80)
+    return unless VMC::Cli::Config.output
+    VMC::Cli::Config.output.print("\r")
+    VMC::Cli::Config.output.print(" " * size)
+    VMC::Cli::Config.output.print("\r")
+    #VMC::Cli::Config.output.flush
+  end
+
+  def err(message, prefix='Error: ')
+    raise VMC::Cli::CliExit, "#{prefix}#{message}"
+  end
+
+  def warn(msg)
+    say "#{"[WARNING]".yellow} #{msg}"
+  end
+
+  def quit(message = nil)
+    raise VMC::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 VMCStringExtensions
+
+  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 VMC::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 VMCExtensions
+end
+
+class String
+  include VMCStringExtensions
+end

data/lib/cli/errors.rb

@@ -0,0 +1,19 @@
+module VMC::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/frameworks.rb

@@ -0,0 +1,138 @@
+module VMC::Cli
+
+  class Framework
+
+    DEFAULT_FRAMEWORK = "http://b20nine.com/unknown"
+    DEFAULT_MEM = '256M'
+
+    FRAMEWORKS = {
+      'Rails'    => ['rails3',  { :mem => '256M', :description => 'Rails Application', :console=>true}],
+      'Spring'   => ['spring',  { :mem => '512M', :description => 'Java SpringSource Spring Application'}],
+      'Grails'   => ['grails',  { :mem => '512M', :description => 'Java SpringSource Grails Application'}],
+      'Lift'   =>   ['lift',    { :mem => '512M', :description => 'Scala Lift Application'}],
+      'JavaWeb'  => ['java_web',{ :mem => '512M', :description => 'Java Web Application'}],
+      'Virgo'    => ['virgo',   { :mem => '256M', :description => 'Eclipse Virgo Application'}],
+      'Sinatra'  => ['sinatra', { :mem => '128M', :description => 'Sinatra Application'}],
+      'Node'     => ['node',    { :mem => '64M',  :description => 'Node.js Application'}],
+      'PHP'      => ['php',     { :mem => '128M', :description => 'PHP Application'}],
+      'Erlang/OTP Rebar' => ['otp_rebar',  { :mem => '64M',  :description => 'Erlang/OTP Rebar Application'}],
+      'WSGI'     => ['wsgi',    { :mem => '64M',  :description => 'Python WSGI Application'}],
+      'Django'   => ['django',  { :mem => '128M', :description => 'Python Django Application'}],
+    }
+
+    class << self
+
+      def known_frameworks
+        FRAMEWORKS.keys
+      end
+
+      def lookup(name)
+        return Framework.new(*FRAMEWORKS[name])
+      end
+
+      def lookup_by_framework(name)
+        FRAMEWORKS.each do |key,fw|
+          return Framework.new(fw[0], fw[1]) if fw[0] == name
+        end
+      end
+
+      def detect(path)
+        Dir.chdir(path) do
+
+          # Rails
+          if File.exist?('config/environment.rb')
+            return Framework.lookup('Rails')
+
+          # Java
+          elsif Dir.glob('*.war').first || File.exist?('WEB-INF/web.xml')
+            war_file = Dir.glob('*.war').first
+
+            if war_file
+              contents = ZipUtil.entry_lines(war_file)
+            else
+              contents = Dir['**/*'].join("\n")
+            end
+
+            # Spring/Lift Variations
+            if contents =~ /WEB-INF\/lib\/grails-web.*\.jar/
+              return Framework.lookup('Grails')
+            elsif contents =~ /WEB-INF\/lib\/lift-webkit.*\.jar/
+              return Framework.lookup('Lift')
+            elsif contents =~ /WEB-INF\/classes\/org\/springframework/
+              return Framework.lookup('Spring')
+            elsif contents =~ /WEB-INF\/lib\/spring-core.*\.jar/
+              return Framework.lookup('Spring')
+            elsif contents =~ /WEB-INF\/lib\/org\.springframework\.core.*\.jar/
+              return Framework.lookup('Spring')
+            else
+              return Framework.lookup('JavaWeb')
+            end
+          # Simple Ruby Apps
+          elsif !Dir.glob('*.rb').empty?
+            matched_file = nil
+            Dir.glob('*.rb').each do |fname|
+              next if matched_file
+              File.open(fname, 'r') do |f|
+                str = f.read # This might want to be limited
+                matched_file = fname if (str && str.match(/^\s*require[\s\(]*['"]sinatra['"]/))
+              end
+            end
+            if matched_file
+              f = Framework.lookup('Sinatra')
+              f.exec = "ruby #{matched_file}"
+              return f
+            end
+
+          # Node.js
+          elsif !Dir.glob('*.js').empty?
+            if File.exist?('server.js') || File.exist?('app.js') || File.exist?('index.js') || File.exist?('main.js')
+              return Framework.lookup('Node')
+            end
+
+          # PHP
+          elsif !Dir.glob('*.php').empty?
+            return Framework.lookup('PHP')
+
+          # Erlang/OTP using Rebar
+          elsif !Dir.glob('releases/*/*.rel').empty? && !Dir.glob('releases/*/*.boot').empty?
+            return Framework.lookup('Erlang/OTP Rebar')
+
+          # Python Django
+          # XXX: not all django projects keep settings.py in top-level directory
+          elsif File.exist?('manage.py') && File.exist?('settings.py')
+            return Framework.lookup('Django')
+
+          # Python
+          elsif !Dir.glob('wsgi.py').empty?
+            return Framework.lookup('WSGI')
+
+          # Virgo
+          elsif !Dir.glob('*.par').empty? || !Dir.glob('*.plan').empty?
+            return Framework.lookup('Virgo')
+
+          end
+        end
+        nil
+      end
+
+    end
+
+    attr_reader   :name, :description, :memory, :console
+    attr_accessor :exec
+
+    alias :mem :memory
+
+    def initialize(framework=nil, opts={})
+      @name = framework || DEFAULT_FRAMEWORK
+      @memory = opts[:mem] || DEFAULT_MEM
+      @description = opts[:description] || 'Unknown Application Type'
+      @exec = opts[:exec]
+      @console = opts[:console] || false
+    end
+
+    def to_s
+      description
+    end
+  end
+
+end