vmc 0.4.0.beta.97 → 0.4.0

data/vmc/lib/cli/core_ext.rb

@@ -1,122 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1,265 +0,0 @@
-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(\/base)?['"]/))
-              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

@@ -1,302 +0,0 @@
-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