olympe 0.1

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/file_helper.rb

@@ -0,0 +1,123 @@
+module VMC::Cli
+  module FileHelper
+    
+    class OLYMPEIgnore
+      
+      def initialize(patterns,project_root = "")
+        @patterns = patterns + [ ".git/" ]
+        @project_root = project_root
+      end
+      
+      def included_files(filenames)
+        exclude_dots_only(filenames).reject do |filename|
+          exclude = false
+          @patterns.each do |pattern|
+            if is_negative_pattern?(pattern)
+              exclude = false if negative_match(pattern,filename)
+            else
+              exclude ||= match(pattern,filename)
+            end
+          end
+          exclude
+        end
+      end
+      
+      def exclude_dots_only(filenames)
+        filenames.reject do |filename|
+          base = File.basename(filename)
+          base == "." || base == ".."
+        end
+      end
+
+      
+      
+      def excluded_files(filenames)
+        filenames - included_files(filenames)
+      end
+
+      def self.from_file(project_root)
+        f = "#{project_root}/.olympeignore"
+        if File.exists?(f) 
+          contents = File.read(f).split("\n")
+          OLYMPEIgnore.new(contents,project_root)
+        else
+          OLYMPEIgnore.new([],project_root)
+        end
+      end
+
+      def match(pattern,filename)
+
+        filename = filename.sub(/^#{@project_root}\//,'') # remove any project directory prefix
+
+        return false if pattern =~ /^\s*$/ # ignore blank lines
+
+        return false if pattern =~ /^#/ # lines starting with # are comments
+
+        return false if pattern =~ /^!/ # lines starting with ! are negated
+      
+        if pattern =~ /\/$/ 
+          # pattern ending in a slash should ignore directory and all its children
+          dirname = pattern.sub(/\/$/,'')
+          return filename == dirname || filename =~ /^#{dirname}\/.*$/
+        end
+      
+        if pattern =~ /^\//
+          parts = filename.split('/')
+          return File.fnmatch(pattern.sub(/^\//,''),parts[0])
+        end
+      
+        if pattern.include? '/'
+          return File.fnmatch(pattern,filename)
+        end
+      
+        File.fnmatch(pattern,filename,File::FNM_PATHNAME)
+      end
+    
+      def is_negative_pattern?(pattern)
+        pattern =~ /^!/
+      end
+    
+      def negative_match(pattern,filename)
+        return false unless pattern =~ /^!/
+        match(pattern.sub(/^!/,''),filename)
+      end
+      
+    end
+    
+    def ignore_sockets(files)
+      files.reject { |f| File.socket? f }
+    end
+    
+    def check_unreachable_links(path,files)
+      pwd = Pathname.new(path)
+      abspath = pwd.realpath.to_s
+      unreachable = []
+      files.each do |f|
+        file = Pathname.new(f)
+        if file.symlink? && !file.realpath.to_s.start_with?(abspath)
+          unreachable << file.relative_path_from(pwd).to_s
+        end
+      end
+
+      unless unreachable.empty?
+        root = pwd.relative_path_from(pwd).to_s
+        err "Can't deploy application containing links '#{unreachable.join(",")}' that reach outside its root '#{root}'"
+      end
+    end
+
+    def copy_files(project_root,files,dest_dir)
+      project_root = Pathname.new(project_root)
+      files.each do |f|
+        dest = Pathname.new(f).relative_path_from(project_root)
+        if File.symlink?(f)
+          FileUtils.copy_entry(f,"#{dest_dir}/#{dest}")
+        elsif File.directory?(f)
+          FileUtils.mkdir_p("#{dest_dir}/#{dest}")
+        else
+          FileUtils.cp(f,"#{dest_dir}/#{dest}")
+        end
+      end      
+    end
+    
+  end
+end

data/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*\#?\s*require\s*\(?\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