rottenegg 1.2.5.beta

data/lib/rotten_egg/message_logger.rb

@@ -0,0 +1,36 @@
+# encoding: utf-8
+
+module RottenEgg
+
+  class MessageLogger
+
+    def initialize
+      @messages = []
+    end
+
+    def counts
+      @messages.length
+    end
+
+    def add(msg)
+      @messages << msg
+    end
+
+    def clear!
+      @messages.clear
+    end
+
+    def tops(size=0)
+      size = 0 if size < 0
+      @messages.slice!(0..size).compact
+    end
+
+    def first
+      tops
+    end
+
+    def pop_all
+      tops(counts-1)
+    end
+  end
+end

data/lib/rotten_egg/scm.rb

@@ -0,0 +1,229 @@
+# encoding: utf-8
+
+require 'nokogiri'
+
+module RottenEgg
+  class Scm
+    TOOLS = %w(git svn).freeze
+
+    def self.get_changes(scm)
+      case scm[:tool]
+        when "git"
+          Git.get_changes(scm)
+        when "svn"
+          Svn.get_changes(scm)
+        else
+          []
+      end
+    end
+
+    class Git < Scm
+      #Actions:  Added (A), Copied (C), Deleted (D), Modified (M), Renamed (R),Changed (T), Unmerged (U), Unknown (X)
+      
+      FILE_ACTIONS = %w(A D M).freeze
+
+      CMD_PROC     = proc do |config, block|
+        aim_branch = config[:branch]
+        Dir.chdir(config[:repository]) do
+          no_remote      = `git remote`.chomp.empty?
+          branches       = `git branch`.chomp.split("\n")
+          current_branch = branches.reject { |branch| branch[0].chr != "*" }.first.gsub("*", '').strip
+          branches.collect! { |branch| branch.gsub('*', '').strip }
+          if branches.include? aim_branch
+            `git checkout #{aim_branch}` if current_branch != aim_branch
+          else
+            if no_remote
+              raise RuntimeError, "fatal: no #{aim_branch} branch"
+            else
+              `git checkout -b #{aim_branch} origin/#{aim_branch}`
+              branches       = `git branch`.chomp.split("\n")
+              current_branch = branches.reject { |branch| branch[0].chr != "*" }.first.gsub("*", '').strip
+              raise RuntimeError, "fatal: git checkout branch #{aim_branch} from origin/#{aim_branch}" if current_branch != aim_branch
+            end
+          end
+          `git pull` unless no_remote
+
+          if config[:first_commit]
+            latest_commit = `git log -1 --format="%H"`.chomp
+            config.update(:latest_commit => latest_commit)
+          else
+            commits = `git log --format="%H"`.chomp.split("\n")
+            latest_commit, first_commit = commits.first, commits.last
+            config.update(:latest_commit => latest_commit, :first_commit => first_commit)
+          end
+          block.call(config) if block
+        end
+      end
+
+      def self.exec(config, &block)
+        CMD_PROC.call(config, block)
+      end
+
+      def self.get_changes(scm)
+        files = Git.exec(scm) do |cfg|
+          if cfg[:remote_commit]
+            if cfg[:remote_commit] == cfg[:latest_commit]
+              []
+            else
+              log   = `git log --pretty=format: --name-status #{cfg[:remote_commit]}..#{cfg[:latest_commit]}`.chomp
+              files = log.split("\n")
+              files.delete ""
+              files.reverse!
+
+            end
+          else
+            log   = `git log --pretty=format: --name-status #{cfg[:first_commit]}..#{cfg[:latest_commit]}`.chomp
+            files = log.split("\n")
+            files.delete ""
+            files.reverse!
+          end
+        end # - exec do block
+
+        files.compact!
+
+        unless files.empty?
+
+          inject_result = files.inject({:file_final_status => {}, :file_names => []}) do |inj_for, item|
+            action, filename = item.split("\t")
+            filename                              = filename.chomp
+            inj_for[:file_final_status][filename] = action.chomp.upcase
+            inj_for[:file_names].delete filename if inj_for[:file_names].index(filename)
+            inj_for[:file_names] << filename
+            inj_for
+          end
+
+          file_hash, files_name = inject_result.delete(:file_final_status), inject_result.delete(:file_names)
+
+          files      = files_name.collect do |filename|
+            if file_hash[filename].nil?
+              nil
+            else
+              if Git::FILE_ACTIONS.include?(file_hash[filename])
+                {:action => file_hash[filename], :filename => filename, :status => :pending}
+              else
+                nil
+              end
+            end
+          end.compact
+        end # - unless files.empty?
+        files
+      end
+
+    end # - Git class
+
+    # currently no svn:externals support TODO?
+    class Svn < Scm
+      #Actions:  Added (A), Deleted (D), Modified (M), Replaced (R)
+
+      FILE_ACTIONS = %w(A D M R).freeze
+
+      CMD_PROC     = proc do |config, block|
+        Dir.chdir(config[:repository]) do
+          # SVN UP ERROR === TODO
+          # svn: OPTIONS of 'http://svn.51hejia.com/51hejia/repos/brands/trunk': could not connect to server (http://svn.51hejia.com)
+          svn_up = Svn.build_command("svn up", config)
+          `#{svn_up}`
+          if config[:first_commit]
+            latest_commit = Svn.latest_revision(config)
+            config.update(:latest_commit => latest_commit)
+          else
+            latest_commit, first_commit = Svn.latest_revision(config), Svn.first_revision(config)
+            config.update(:latest_commit => latest_commit, :first_commit => first_commit)
+          end
+          block.call(config) if block
+        end
+      end
+
+      def self.exec(config, &block)
+        CMD_PROC.call(config, block)
+      end
+
+      def self.build_command(cmd, config)
+        cmd << " --username=#{config[:user]} --password=#{config[:password]} --no-auth-cache" if config[:authorize]
+        cmd
+      end
+
+      def self.first_revision(config={})
+        cmd    = build_command("svn log -q -r 0:HEAD --limit=1", config)
+        result = `#{cmd}`.chomp!
+        lines  = result.split("\n").reverse
+        line   = lines[1]
+        line.nil? ? '' : line.scan(/\Ar\d+/).first.to_s.gsub("r", '')
+      end
+
+      def self.latest_revision(config={})
+        cmd    = build_command("svn info -r HEAD", config)
+        result = `#{cmd}`.chomp!
+        lines  = result.split("\n").reverse
+        line   = lines[1]
+        line.nil? ? '' : line.scan(/\d+/).first.to_s
+      end
+
+      def self.parse_log(xml, sanitize_paths)
+        paths = sanitize_paths.split("|")
+        xml_doc         = Nokogiri::XML(xml)
+        files           = xml_doc.xpath("//path").collect do |node|
+          if node["kind"] == "file"
+            file_path = node.text.to_s
+            file_path = file_path.gsub(%r(\A#{paths.join("|")}), '').strip
+            file_path.empty? ? nil : "#{node["action"]}\t#{file_path}"
+          else
+            nil
+          end
+        end.compact
+        files
+      end
+
+      def self.get_changes(scm)
+        files = Svn.exec(scm) do |cfg|
+          if cfg[:remote_commit]
+            if cfg[:remote_commit] == cfg[:latest_commit]
+              []
+            else
+              cmd   = Svn.build_command("svn log -v -r #{cfg[:remote_commit]}:#{cfg[:latest_commit]} --xml", cfg)
+              log   = `#{cmd}`.chomp
+              Svn.parse_log(log, cfg[:sanitize_path_prefix])
+            end
+          else
+            cmd   = Svn.build_command("svn log -v -r #{cfg[:first_commit]}:#{cfg[:latest_commit]} --xml", cfg)
+            log   = `#{cmd}`.chomp
+            Svn.parse_log(log, cfg[:sanitize_path_prefix])
+          end
+        end # - exec do block
+
+        files.compact!
+
+        unless files.empty?
+
+          inject_result = files.inject({:file_final_status => {}, :file_names => []}) do |inj_for, item|
+            action, filename = item.split("\t")
+            filename                              = filename.chomp
+            inj_for[:file_final_status][filename] = action.chomp.upcase
+            inj_for[:file_names].delete filename if inj_for[:file_names].index(filename)
+            inj_for[:file_names] << filename
+            inj_for
+          end
+
+          file_hash, files_name = inject_result.delete(:file_final_status), inject_result.delete(:file_names)
+
+          files      = files_name.collect do |filename|
+            if file_hash[filename].nil?
+              nil
+            else
+              if Svn::FILE_ACTIONS.include?(file_hash[filename])
+                # replace 'Replaced(R)' to 'Modified(M)'
+                {:action => (file_hash[filename] == "R" ? "M" : file_hash[filename]), :filename => filename, :status => :pending}
+              else
+                nil
+              end
+            end
+          end.compact
+        end # - unless files.empty?
+
+        files
+      end
+
+    end
+
+  end # - Scm class
+end # - RottenEgg module

data/lib/rotten_egg/server.rb

@@ -0,0 +1,238 @@
+# encoding: utf-8
+
+require 'optparse'
+require 'yaml'
+require 'fileutils'
+
+module RottenEgg
+  class Server
+
+    # server start up options
+    class Options
+      def parse!(args)
+        options    = {}
+        opt_parser = OptionParser.new("", 40, '  ') do |opts|
+          opts.banner = "Usage: rotten_egg options"
+
+          opts.separator ""
+          opts.separator "options:"
+
+#          lineno = 1
+#          opts.on("-e", "--eval LINE", "evaluate a LINE of code") { |line|
+#            eval line, TOPLEVEL_BINDING, "-e", lineno
+#            lineno += 1
+#          }
+
+#          opts.on("-d", "--debug", "set debugging flags (set $DEBUG to true)") {
+#            options[:debug] = true
+#          }
+#
+#          opts.on("-w", "--warn", "turn warnings on for your script") {
+#            options[:warn] = true
+#          }
+
+#          opts.on("-s", "--server SERVER", "serve using SERVER (thin)") { |s|
+#            options[:server] = s
+#          }
+
+          opts.on("-o", "--host HOST", "listen on HOST (default: 0.0.0.0)") { |host|
+            options[:host] = host
+          }
+
+          opts.on("-p", "--port PORT", "use PORT (default: 17420)") { |port|
+            options[:port] = port
+          }
+
+          opts.on("-e", "--env ENVIRONMENT", "use ENVIRONMENT (default: development)") { |e|
+            options[:environment] = e.to_sym
+          }
+
+          opts.on("-C", "--config FILE", "app config file (default: rotten_egg.yml)") { |c|
+            options[:config] = c
+          }
+
+          opts.on("-A", "--auth FILE", "app auth file (if nil default auth: user:'rotten' password:'egg')") { |a|
+            options[:auth_file] = a
+          }
+
+          opts.on("-W", "--working_directory DIRECTORY", "app working directory") { |w|
+            options[:working_directory] = w
+          }
+
+          opts.on("-m", "--paging_size SIZE", "max perpage for paginate") { |ps|
+            options[:paging_size] = ps
+          }
+
+          opts.separator ""
+          opts.separator "Daemonize options:"
+
+          opts.on("-D", "--daemonize", "run daemonized in the background") { |d|
+            options[:daemonize] = d ? true : false
+          }
+
+          opts.on("-u", "--user NAME", "User to run daemon as (use with -g)") { |u|
+            options[:user] = u
+          }
+
+          opts.on("-g", "--group NAME", "Group to run daemon as (use with -u)") { |g|
+            options[:group] = g
+          }
+
+          opts.on("-P", "--pid FILE", "file to store PID (default: rotten_egg.pid)") { |f|
+            options[:pid] = f
+          }
+
+          opts.on("-l", "--log FILE", "file to store log") { |l|
+            options[:log] = l
+          }
+
+          opts.separator ""
+          opts.separator "Common options:"
+
+          opts.on_tail("-h", "--help", "Show this message") do
+            puts opts
+            exit
+          end
+
+          opts.on_tail("--version", "Show version") do
+            puts "RottenEgg #{RottenEgg.version}, release #{RottenEgg.release}"
+            exit
+          end
+        end
+        opt_parser.parse! args
+        unless options[:config]
+          options[:config] = args.last if args.last
+        end
+        options
+      end
+    end
+
+    attr_writer :options
+
+    def initialize(options)
+      @options = options
+    end
+
+    def options
+      @options ||= parse_options(ARGV)
+    end
+
+    def self.start(options = nil)
+      new(options).start
+    end
+
+    def default_options
+      {
+        :environment          => :development,
+        :pid                  => nil,
+        :daemonize            => false,
+        :server               => "thin",
+        :port                 => 14720,
+        :host                 => "0.0.0.0",
+        :log                  => nil,
+        :config               => nil,
+        :auth_file            => nil,
+        :working_directory    => ENV['PWD'],
+        :page_size            => 50
+      }
+    end
+
+    def start
+#      if options[:debug]
+#        $DEBUG = true
+#        require 'pp'
+#        p options[:server]
+#        pp wrapped_app
+#        pp app
+#      end
+#
+#      if options[:warn]
+#        $-w = true
+#      end
+
+      options[:working_directory] = File.expand_path options[:working_directory], ENV['PWD']
+      options[:working_directory] = Util.format_path options[:working_directory] 
+
+      options[:paging_size] = options[:paging_size].to_i <= 0 ? 50 : options[:paging_size].to_i
+      
+      Application.set :apps_setting, {}
+      Application.set :paging_size, options[:paging_size]
+      if options[:config]
+        unless File.exist? options[:config]
+          abort "app configuration #{options[:config]} not found"
+        else
+          setting                                  = begin
+            AppSetting.parse! options[:config], true
+          rescue Exception => e
+            abort "#{e.message}"
+          end
+          name = setting.delete(:name)
+          Application.apps_setting[name]  = setting
+        end
+      end
+
+      if options[:auth_file]
+        unless File.exist? options[:auth_file]
+          abort "app auth file #{options[:auth_file]} not found"
+        else
+          Application.set :auth_user, YAML::load_file(options[:auth_file])
+        end
+      else
+        Application.set :auth_user, {"user" => "rotten", "password" => "egg"}
+      end
+
+      options.delete :auth_file
+
+      daemonize_app if options[:daemonize]
+      write_pid if options[:pid]
+
+      FileUtils.mkdir_p options[:working_directory] unless File.directory? options[:working_directory]
+      options[:log] = "#{options[:working_directory]}/#{options[:environment]}.log" unless options[:log]
+      log_file = options[:log]
+      FileUtils.mkdir_p File.dirname(log_file) unless File.directory? File.dirname(log_file)
+
+      if options[:daemonize] or options[:environment].to_s == "production"
+        $old_stdout = $stdout # in case you want to turn off traces
+        $stdout = File.new(log_file, 'w')
+        $stdout.sync = true
+        $stderr.reopen($stdout)
+        $stderr = $stdout
+      end
+
+      Application.run! options
+    end
+
+    private
+
+    def parse_options(args)
+      options = default_options
+      options.merge! opt_parser.parse! args
+      ENV["RACK_ENV"] = options[:environment].to_s
+      options
+    end
+
+    def opt_parser
+      Options.new
+    end
+
+    def daemonize_app
+      if RUBY_VERSION < "1.9"
+        exit if fork
+        Process.setsid
+        exit if fork
+        Dir.chdir "/"
+        File.umask 0000
+        STDIN.reopen "/dev/null"
+        STDOUT.reopen "/dev/null", "a"
+        STDERR.reopen "/dev/null", "a"
+      else
+        Process.daemon
+      end
+    end
+
+    def write_pid
+      File.open(options[:pid], 'w') { |f| f.write("#{Process.pid}") }
+      at_exit { File.delete(options[:pid]) if File.exist?(options[:pid]) }
+    end
+  end
+end