vmc 0.4.0.beta.6 → 0.4.0.beta.7

data/vmc/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/vmc/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/vmc/lib/cli/frameworks.rb

@@ -0,0 +1,265 @@
+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'}],
+      'Standalone'     => ['standalone',    { :mem => '64M', :description => 'Standalone 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'}],
+      'dotNet'   => ['dotNet',  { :mem => '128M', :description => '.Net Web Application'}],
+      'Rack'     => ['rack', { :mem => '128M', :description => 'Rack Application'}],
+      'Play'     => ['play',  { :mem => '256M', :description => 'Play Framework Application'}]
+    }
+
+    class << self
+
+      def known_frameworks(available_frameworks)
+        frameworks = []
+        FRAMEWORKS.each do |key,fw|
+          frameworks << key if available_frameworks.include? [fw[0]]
+        end
+        frameworks
+      end
+
+      def lookup(name)
+        return create(*FRAMEWORKS[name])
+      end
+
+      def lookup_by_framework(name)
+        FRAMEWORKS.each do |key,fw|
+          return create(fw[0],fw[1]) if fw[0] == name
+        end
+      end
+
+      def create(name,opts)
+        if name == "standalone"
+          return StandaloneFramework.new(name, opts)
+        else
+          return Framework.new(name,opts)
+        end
+      end
+
+      def detect(path, available_frameworks)
+        if !File.directory? path
+          if path.end_with?('.war')
+            return detect_framework_from_war path
+          elsif path.end_with?('.zip')
+            return detect_framework_from_zip path, available_frameworks
+          elsif available_frameworks.include?(["standalone"])
+            return Framework.lookup('Standalone')
+          else
+            return nil
+          end
+        end
+        Dir.chdir(path) do
+          # Rails
+          if File.exist?('config/environment.rb')
+            return Framework.lookup('Rails')
+
+          # Rack
+          elsif File.exist?('config.ru') && available_frameworks.include?(["rack"])
+            return Framework.lookup('Rack')
+
+          # Java Web Apps
+          elsif Dir.glob('*.war').first
+            return detect_framework_from_war(Dir.glob('*.war').first)
+
+          elsif File.exist?('WEB-INF/web.xml')
+            return detect_framework_from_war
+
+          # 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
+              # Sinatra apps
+              f = Framework.lookup('Sinatra')
+              f.exec = "ruby #{matched_file}"
+              return f
+            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')
+
+          # .Net
+          elsif !Dir.glob('web.config').empty?
+            return Framework.lookup('dotNet')
+
+          # 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
+
+          # Play or Standalone Apps
+          elsif Dir.glob('*.zip').first
+            zip_file = Dir.glob('*.zip').first
+            return detect_framework_from_zip zip_file, available_frameworks
+          end
+
+          # Default to Standalone if no other match was made
+          return Framework.lookup('Standalone') if available_frameworks.include?(["standalone"])
+        end
+      end
+
+      def detect_framework_from_war(war_file=nil)
+        if war_file
+          contents = ZipUtil.entry_lines(war_file)
+        else
+          #assume we are working with current dir
+          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
+      end
+
+      def detect_framework_from_zip(zip_file, available_frameworks)
+        contents = ZipUtil.entry_lines(zip_file)
+        detect_framework_from_zip_contents(contents, available_frameworks)
+      end
+
+      def detect_framework_from_zip_contents(contents, available_frameworks)
+        if available_frameworks.include?(["play"]) && contents =~ /lib\/play\..*\.jar/
+          return Framework.lookup('Play')
+        elsif available_frameworks.include?(["standalone"])
+          return Framework.lookup('Standalone')
+        end
+      end
+    end
+
+    attr_reader   :name, :description, :console
+    attr_accessor :exec
+
+    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
+
+    def require_url?
+      true
+    end
+
+    def require_start_command?
+      false
+    end
+
+    def prompt_for_runtime?
+      false
+    end
+
+    def default_runtime(path)
+      nil
+    end
+
+    def memory(runtime=nil)
+      @memory
+    end
+
+    alias :mem :memory
+  end
+
+  class StandaloneFramework < Framework
+    def require_url?
+      false
+    end
+
+    def require_start_command?
+      true
+    end
+
+    def prompt_for_runtime?
+      true
+    end
+
+    def default_runtime(path)
+      if !File.directory? path
+        if path =~ /\.(jar|class)$/
+          return "java"
+        elsif path =~ /\.(rb)$/
+          return "ruby18"
+        elsif path =~ /\.(zip)$/
+          return detect_runtime_from_zip path
+        end
+      else
+        Dir.chdir(path) do
+          return "ruby18" if not Dir.glob('**/*.rb').empty?
+          if !Dir.glob('**/*.class').empty? || !Dir.glob('**/*.jar').empty?
+            return "java"
+          elsif Dir.glob('*.zip').first
+            zip_file = Dir.glob('*.zip').first
+            return detect_runtime_from_zip zip_file
+          end
+        end
+      end
+      return nil
+    end
+
+    def memory(runtime=nil)
+      default_mem = @memory
+      default_mem = '128M' if runtime =~ /\Aruby/ || runtime == "php"
+      default_mem = '512M' if runtime == "java" || runtime == "java7"
+      default_mem
+    end
+
+    private
+    def detect_runtime_from_zip(zip_file)
+      contents = ZipUtil.entry_lines(zip_file)
+      if contents =~ /\.(jar)$/
+        return "java"
+      end
+    end
+  end
+
+end

data/vmc/lib/cli/manifest_helper.rb

@@ -0,0 +1,302 @@
+require "set"
+
+module VMC::Cli::ManifestHelper
+  include VMC::Cli::ServicesHelper
+
+  DEFAULTS = {
+    "url" => "${name}.${target-base}",
+    "mem" => "128M",
+    "instances" => 1
+  }
+
+  MANIFEST = "manifest.yml"
+
+  YES_SET = Set.new(["y", "Y", "yes", "YES"])
+
+  # take a block and call it once for each app to push/update.
+  # with @application and @app_info set appropriately
+  def each_app(panic=true)
+    if @manifest and all_apps = @manifest["applications"]
+      where = File.expand_path(@path)
+      single = false
+
+      all_apps.each do |path, info|
+        app = File.expand_path("../" + path, manifest_file)
+        if where.start_with?(app)
+          @application = app
+          @app_info = info
+          yield info["name"]
+          single = true
+          break
+        end
+      end
+
+      unless single
+        if where == File.expand_path("../", manifest_file)
+          ordered_by_deps(all_apps).each do |path, info|
+            app = File.expand_path("../" + path, manifest_file)
+            @application = app
+            @app_info = info
+            yield info["name"]
+          end
+        else
+          err "Path '#{@path}' is not known to manifest '#{manifest_file}'."
+        end
+      end
+    else
+      @application = @path
+      @app_info = @manifest
+      if @app_info
+        yield @app_info["name"]
+      elsif panic
+        err "No applications."
+      end
+    end
+
+    nil
+  ensure
+    @application = nil
+    @app_info = nil
+  end
+
+  def interact(many=false)
+    @manifest ||= {}
+    configure_app(many)
+  end
+
+  def target_manifest
+    @options[:manifest] || MANIFEST
+  end
+
+  def save_manifest(save_to = nil)
+    save_to ||= target_manifest
+
+    File.open(save_to, "w") do |f|
+      f.write @manifest.to_yaml
+    end
+
+    say "Manifest written to #{save_to}."
+  end
+
+  def configure_app(many=false)
+    name = manifest("name") ||
+      set(ask("Application Name", :default => manifest("name")), "name")
+
+
+
+    if manifest "framework"
+      framework = VMC::Cli::Framework.lookup_by_framework manifest("framework","name")
+    else
+      framework = detect_framework
+      set framework.name, "framework", "name"
+      set(
+        { "mem" => framework.mem,
+          "description" => framework.description,
+          "exec" => framework.exec
+        },
+        "framework",
+        "info"
+      )
+    end
+
+    default_runtime = manifest "runtime"
+    if not default_runtime
+      default_runtime = framework.default_runtime(@application)
+      set(detect_runtime(default_runtime), "runtime") if framework.prompt_for_runtime?
+    end
+    default_command = manifest "command"
+    set ask("Start Command", :default => default_command), "command" if framework.require_start_command?
+
+    url_template = manifest("url") || DEFAULTS["url"]
+    url_resolved = url_template.dup
+    resolve_lexically(url_resolved)
+
+    if !framework.require_url?
+      url_resolved = "None"
+    end
+    url = ask("Application Deployed URL", :default => url_resolved)
+
+    if url == url_resolved && url != "None"
+      url = url_template
+    end
+
+    # common error case is for prompted users to answer y or Y or yes or
+    # YES to this ask() resulting in an unintended URL of y. Special
+    # case this common error
+    url = url_resolved if YES_SET.member? url
+
+    if(url == "None")
+      url = nil
+    end
+
+    set url, "url"
+
+    default_mem = manifest("mem")
+    default_mem = framework.memory(manifest("runtime")) if not default_mem
+    set ask(
+      "Memory reservation",
+      :default =>
+          default_mem ||
+          DEFAULTS["mem"],
+      :choices => ["128M", "256M", "512M", "1G", "2G"]
+    ), "mem"
+
+    set ask(
+      "How many instances?",
+      :default => manifest("instances") || DEFAULTS["instances"]
+    ), "instances"
+
+    unless manifest "services"
+      user_services = client.services
+      user_services.sort! {|a, b| a[:name] <=> b[:name] }
+
+      unless user_services.empty?
+        if ask "Bind existing services to '#{name}'?", :default => false
+          bind_services(user_services)
+        end
+      end
+
+      services = client.services_info
+      unless services.empty?
+        if ask "Create services to bind to '#{name}'?", :default => false
+          create_services(services.values.collect(&:keys).flatten)
+        end
+      end
+    end
+
+    if many and ask("Configure for another application?", :default => false)
+      @application = ask "Application path?"
+      configure_app
+    end
+  end
+
+  def set(what, *where)
+    where.unshift "applications", @application
+
+    which = @manifest
+    where.each_with_index do |k, i|
+      if i + 1 == where.size
+        which[k] = what
+      else
+        which = (which[k] ||= {})
+      end
+    end
+
+    what
+  end
+
+  # Detect the appropriate framework.
+  def detect_framework(prompt_ok = true)
+    framework = VMC::Cli::Framework.detect(@application, frameworks_info)
+    framework_correct = ask("Detected a #{framework}, is this correct?", :default => true) if prompt_ok && framework
+    if prompt_ok && (framework.nil? || !framework_correct)
+      display "#{"[WARNING]".yellow} Can't determine the Application Type." unless framework
+      framework = nil if !framework_correct
+      framework = VMC::Cli::Framework.lookup(
+        ask(
+          "Select Application Type",
+          :indexed => true,
+          :default => framework,
+          :choices => VMC::Cli::Framework.known_frameworks(frameworks_info)
+        )
+      )
+      display "Selected #{framework}"
+    end
+
+    framework
+  end
+
+  # Detect the appropriate runtime.
+  def detect_runtime(default, prompt_ok=true)
+    runtime = nil
+    runtime_keys=[]
+    runtimes_info.keys.each {|runtime_key| runtime_keys << runtime_key.dup }
+    runtime_keys.sort!
+    if prompt_ok
+      runtime =  ask(
+          "Select Runtime",
+          :indexed => true,
+          :default => default,
+          :choices => runtime_keys
+      )
+      display "Selected #{runtime}"
+    end
+    runtime
+  end
+
+  def bind_services(user_services, chosen = 0)
+    svcname = ask(
+      "Which one?",
+      :indexed => true,
+      :choices => user_services.collect { |p| p[:name] })
+
+    svc = user_services.find { |p| p[:name] == svcname }
+
+    set svc[:vendor], "services", svcname, "type"
+
+    if chosen + 1 < user_services.size && ask("Bind another?", :default => false)
+      bind_services(user_services, chosen + 1)
+    end
+  end
+
+  def create_services(services)
+    svcs = services.collect(&:to_s).sort!
+
+    configure_service(
+      ask(
+        "What kind of service?",
+        :indexed => true,
+        :choices => svcs
+      )
+    )
+
+    if ask "Create another?", :default => false
+      create_services(services)
+    end
+  end
+
+  def configure_service(vendor)
+    default_name = random_service_name(vendor)
+    name = ask "Specify the name of the service", :default => default_name
+
+    set vendor, "services", name, "type"
+  end
+
+  private
+    def ordered_by_deps(apps, abspaths = nil, processed = Set[])
+      unless abspaths
+        abspaths = {}
+        apps.each do |p, i|
+          ep = File.expand_path("../" + p, manifest_file)
+          abspaths[ep] = i
+        end
+      end
+
+      ordered = []
+      apps.each do |path, info|
+        epath = File.expand_path("../" + path, manifest_file)
+
+        if deps = info["depends-on"]
+          dep_apps = {}
+          deps.each do |dep|
+            edep = File.expand_path("../" + dep, manifest_file)
+
+            err "Circular dependency detected." if processed.include? edep
+
+            dep_apps[dep] = abspaths[edep]
+          end
+
+          processed.add(epath)
+
+          ordered += ordered_by_deps(dep_apps, abspaths, processed)
+          ordered << [path, info]
+        elsif not processed.include? epath
+          ordered << [path, info]
+          processed.add(epath)
+        end
+      end
+
+      ordered
+    end
+
+end