vmc 0.0.8 → 0.2.4

data/lib/cli/commands/base.rb

@@ -0,0 +1,56 @@
+
+require 'rubygems'
+require 'terminal-table/import'
+require 'highline/import'
+
+module VMC::Cli
+
+  module Command
+
+    class Base
+      attr_reader :no_prompt, :prompt_ok
+
+      def initialize(options={})
+        @options = options.dup
+        @no_prompt = @options[:noprompts]
+        @prompt_ok = !no_prompt
+
+        # Fix for system ruby and Highline (stdin) on MacOSX
+        if RUBY_PLATFORM =~ /darwin/ && RUBY_VERSION == '1.8.7' && RUBY_PATCHLEVEL <= 174
+          HighLine.track_eof = false
+        end
+
+        # Suppress colorize on Windows systems for now.
+        if !!RUBY_PLATFORM['mingw'] || !!RUBY_PLATFORM['mswin32'] || !!RUBY_PLATFORM['cygwin']
+          VMC::Cli::Config.colorize = false
+        end
+
+      end
+
+      def client
+        return @client if @client
+        @client = VMC::Client.new(target_url, auth_token)
+        @client.trace = true if VMC::Cli::Config.trace
+        @client.proxy_for @options[:proxy] if @options[:proxy]
+        @client
+      end
+
+      def client_info
+        return @client_info if @client_info
+        @client_info = client.info
+      end
+
+      def target_url
+        return @target_url if @target_url
+        @target_url = VMC::Cli::Config.target_url
+      end
+
+      def auth_token
+        return @auth_token if @auth_token
+        @auth_token = VMC::Cli::Config.auth_token
+      end
+
+    end
+  end
+end
+

data/lib/cli/commands/misc.rb

@@ -0,0 +1,99 @@
+module VMC::Cli::Command
+
+  class Misc < Base
+    def version
+      say "vmc #{VMC::Cli::VERSION}"
+    end
+
+    def target
+      return display JSON.pretty_generate({:target => target_url}) if @options[:json]
+      banner "[#{target_url}]"
+    end
+
+    def targets
+      targets = VMC::Cli::Config.targets
+      return display JSON.pretty_generate(targets) if @options[:json]
+      return display 'None specified' if targets.empty?
+      targets_table = table do |t|
+        t.headings = 'Target', 'Authorization'
+        targets.each { |target, token| t << [target, token] }
+      end
+      display "\n"
+      display targets_table
+    end
+
+    alias :tokens :targets
+
+    def set_target(target_url)
+      target_url = "http://#{target_url}" unless /^https?/ =~ target_url
+      client = VMC::Client.new(target_url)
+      unless client.target_valid?
+        if prompt_ok
+          display "Host is not valid: '#{target_url}'".red
+          show_response = ask "Would you like see the response [yN]? "
+          display "\n<<<\n#{client.raw_info}\n>>>\n" if show_response.upcase == 'Y'
+        end
+        exit(false)
+      else
+        VMC::Cli::Config.store_target(target_url)
+        say "Succesfully targeted to [#{target_url}]".green
+      end
+    end
+
+    def info
+      info = client.info
+      return display JSON.pretty_generate(info) if @options[:json]
+
+      display "\n#{info[:description]}"
+      display "For support visit #{info[:support]}"
+      display ""
+      display "Target:   #{target_url} (v#{info[:version]})"
+      display "Client:   v#{VMC::Cli::VERSION}"
+      if info[:user]
+        display ''
+        display "User:     #{info[:user]}"
+      end
+      if usage = info[:usage] and limits = info[:limits]
+        tmem  = pretty_size(limits[:memory]*1024*1024)
+        mem   = pretty_size(usage[:memory]*1024*1024)
+        tser  = limits[:services]
+        ser   = usage[:services]
+        tapps = limits[:apps] || 0
+        apps  = usage[:apps]  || 0
+        display "Usage:    Memory   (#{mem} of #{tmem} total)"
+        display "          Services (#{ser} of #{tser} total)"
+        display "          Apps     (#{apps} of #{tapps} total)" if limits[:apps]
+      end
+    end
+
+    def aliases
+      aliases = VMC::Cli::Config.aliases
+      return display JSON.pretty_generate(aliases) if @options[:json]
+      return display "No Aliases" if aliases.empty?
+      atable = table do |t|
+        t.headings = 'Alias', "Command"
+        aliases.each { |k,v| t << [v, k] }
+      end
+      display "\n"
+      display atable
+    end
+
+    def alias(k, v=nil)
+      k,v = k.split('=') unless v
+      aliases = VMC::Cli::Config.aliases
+      aliases[k] = v
+      VMC::Cli::Config.store_aliases(aliases)
+      display "Successfully aliased '#{k}' to '#{v}'".green
+    end
+
+    def unalias(key)
+      aliases = VMC::Cli::Config.aliases
+      aliases.delete(key)
+      VMC::Cli::Config.store_aliases(aliases)
+      display "Successfully unaliased '#{key}'".green
+    end
+
+  end
+
+end
+

data/lib/cli/commands/services.rb

@@ -0,0 +1,84 @@
+module VMC::Cli::Command
+
+  class Services < Base
+    include VMC::Cli::ServicesHelper
+
+    def services
+      ss = client.services_info
+      ps = client.services
+      if @options[:json]
+        services = { :system => ss, :provisioned => ps }
+        return display JSON.pretty_generate(services)
+      end
+      display_system_services(ss)
+      display_provisioned_services(ps)
+    end
+
+    def create_service(service=nil, name=nil, appname=nil)
+      unless no_prompt || service
+        services = client.services_info
+        err 'No services available to provision' if services.empty?
+        choose do |menu|
+          menu.prompt = 'Please select one you wish to provision: '
+          menu.select_by = :index_or_name
+          services.each do |service_type, value|
+            value.each do |vendor, version|
+              menu.choice(vendor.to_s) { service = vendor.to_s }
+            end
+          end
+        end
+      end
+      name = @options[:name] unless name
+      unless name
+        name = random_service_name(service)
+        picked_name = true
+      end
+      create_service_banner(service, name, picked_name)
+      appname = @options[:bind] unless appname
+      bind_service_banner(name, appname) if appname
+    end
+
+    def delete_service(service=nil)
+      unless no_prompt || service
+        user_services = client.services
+        err 'No services available to delete' if user_services.empty?
+        choose do |menu|
+          menu.prompt = 'Please select one you wish to delete: '
+          menu.select_by = :index_or_name
+          user_services.each do |s|
+            menu.choice(s[:name]) { service = s[:name] }
+          end
+        end
+      end
+      err "Service name required." unless service
+      display "Deleting service [#{service}]: ", false
+      client.delete_service(service)
+      display 'OK'.green
+    end
+
+    def bind_service(service, appname)
+      bind_service_banner(service, appname)
+    end
+
+    def unbind_service(service, appname)
+      unbind_service_banner(service, appname)
+    end
+
+    def clone_services(src_app, dest_app)
+      begin
+        src  = client.app_info(src_app)
+        dest = client.app_info(dest_app)
+      rescue
+      end
+
+      err "Application '#{src_app}' does not exist" unless src
+      err "Application '#{dest_app}' does not exist" unless dest
+
+      services = src[:services]
+      err 'No services to clone' unless services && !services.empty?
+      services.each { |service| bind_service_banner(service, dest_app, false) }
+      check_app_for_restart(dest_app)
+    end
+
+  end
+end

data/lib/cli/commands/user.rb

@@ -0,0 +1,60 @@
+module VMC::Cli::Command
+
+  class User < Base
+
+    def info
+      info = client.info
+      username = info[:user] || 'N/A'
+      return display JSON.pretty_generate([username]) if @options[:json]
+      display "\n[#{username}]"
+    end
+
+    def login(email=nil)
+      email    = @options[:email] unless email
+      password = @options[:password]
+      tries = 0
+      email = ask("Email: ") unless no_prompt || email
+      password = ask("Password: ") {|q| q.echo = '*'} unless no_prompt || password
+      err "Need a valid email" unless email
+      err "Need a password" unless password
+      login_and_save_token(email, password)
+      say "Successfully logged into [#{target_url}]".green
+    rescue VMC::Client::TargetError
+      display "Problem with login, invalid account or password.".red
+      retry if (tries += 1) < 3 && prompt_ok
+      exit 1
+    rescue => e
+      display "Problem with login, #{e}, try again or register for an account.".red
+      exit 1
+    end
+
+    def logout
+      VMC::Cli::Config.remove_token_file
+      say "Successfully logged out of [#{target_url}]".green
+    end
+
+    def change_password(password=nil)
+      info = client.info
+      email = info[:user]
+      err "Need to be logged in to change password." unless email
+      say "Changing password for '#{email}'\n"
+      unless no_prompt
+        password = ask("New Password: ") {|q| q.echo = '*'}
+        password2 = ask("Verify Password: ") {|q| q.echo = '*'}
+        err "Passwords did not match, try again" if password != password2
+      end
+      err "Password required" unless password
+      client.change_password(password)
+      say "\nSuccessfully changed password".green
+    end
+
+    private
+
+    def login_and_save_token(email, password)
+      token = client.login(email, password)
+      VMC::Cli::Config.store_token(token)
+    end
+
+  end
+
+end

data/lib/cli/config.rb

@@ -0,0 +1,109 @@
+require "yaml"
+require 'fileutils'
+
+require 'rubygems'
+require 'json/pure'
+
+module VMC::Cli
+  class Config
+
+    DEFAULT_TARGET  = 'api.vcap.me'
+    DEFAULT_SUGGEST = 'vcap.me'
+
+    TARGET_FILE    = '~/.vmc_target'
+    TOKEN_FILE     = '~/.vmc_token'
+    INSTANCES_FILE = '~/.vmc_instances'
+    ALIASES_FILE   = '~/.vmc_aliases'
+
+    class << self
+      attr_accessor :colorize
+      attr_accessor :output
+      attr_accessor :trace
+      attr_accessor :nozip
+      attr_reader   :suggest_url
+
+      def target_url
+        return @target_url if @target_url
+        target_file = File.expand_path(TARGET_FILE)
+        if File.exists? target_file
+          @target_url = File.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
+      end
+
+      def store_target(target_host)
+        target_file = File.expand_path(TARGET_FILE)
+        File.open(target_file, 'w+') { |f| f.puts target_host }
+        FileUtils.chmod 0600, target_file
+      end
+
+      def all_tokens
+        token_file = File.expand_path(TOKEN_FILE)
+        return nil unless File.exists? token_file
+        contents = File.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)
+        File.open(token_file, 'w+') { |f| f.write(tokens.to_json) }
+        FileUtils.chmod 0600, token_file
+      end
+
+      def instances
+        instances_file = File.expand_path(INSTANCES_FILE)
+        return nil unless File.exists? instances_file
+        contents = File.read(instances_file).strip
+        JSON.parse(contents)
+      end
+
+      def store_instances(instances)
+        instances_file = File.expand_path(INSTANCES_FILE)
+        File.open(instances_file, 'w') { |f| f.write(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
+
+    end
+
+    def initialize(work_dir = Dir.pwd)
+      @work_dir = work_dir
+    end
+
+  end
+end

data/lib/cli/core_ext.rb

@@ -0,0 +1,119 @@
+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 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,97 @@
+module VMC::Cli
+
+  class Framework
+
+    DEFAULT_FRAMEWORK = "http://b20nine.com/unknown"
+    DEFAULT_MEM = '256M'
+
+    FRAMEWORKS = {
+      'Rails'    => ['rails/1.0', { :mem => '256M', :description => 'Rails Application'}],
+      'Spring'   => ['spring_web/1.0', { :mem => '512M', :description => 'Java SpringSource Spring Application'}],
+      'Grails'   => ['grails/1.0', { :mem => '512M', :description => 'Java SpringSource Grails Application'}],
+      'Roo'      => ['spring_web/1.0', { :mem => '512M', :description => 'Java SpringSource Roo Application'}],
+      'JavaWeb'  => ['spring_web/1.0', { :mem => '512M', :description => 'Java Web Application'}],
+      'Sinatra'  => [DEFAULT_FRAMEWORK, { :mem => '128M', :description => 'Sinatra Application'}],
+      'Node'     => ['nodejs/1.0', { :mem => '64M', :description => 'NodeJS Application'}],
+    }
+
+    class << self
+
+      def known_frameworks
+        FRAMEWORKS.keys
+      end
+
+      def lookup(name)
+        return Framework.new(*FRAMEWORKS[name])
+      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
+            war_file = Dir.glob('*.war').first
+            contents = ZipUtil.entry_lines(war_file)
+
+            # Spring Variations
+            if contents =~ /WEB-INF\/grails-app/
+              return Framework.lookup('Grails')
+            elsif contents =~ /WEB-INF\/classes\/org\/springframework/
+              return Framework.lookup('Spring')
+            elsif contents =~ /WEB-INF\/lib\/spring-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 && !File.exist?('config.ru')
+              f = Framework.lookup('Sinatra')
+              f.exec = "ruby #{matched_file}"
+              return f
+            end
+
+          # Node.JS
+          elsif !Dir.glob('*.js').empty?
+            # Fixme, make other files work too..
+            if File.exist?('app.js') || File.exist?('index.js') || File.exist?('main.js')
+              return Framework.lookup('Node')
+            end
+          end
+        end
+        nil
+      end
+
+    end
+
+    attr_reader   :name, :description, :memory
+    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]
+    end
+
+    def to_s
+      description
+    end
+  end
+
+end