rottenegg 1.2.5.beta

data/.gitignore

@@ -0,0 +1,7 @@
+*.gem
+.bundle
+.idea
+.DS_Store
+Gemfile.lock
+pkg/*
+tmp

data/.rvmrc

@@ -0,0 +1 @@
+rvm use 1.9.2

data/Gemfile

@@ -0,0 +1,14 @@
+# encoding: utf-8
+source "http://rubygems.org"
+
+gem 'thin'
+gem 'sinatra', '~> 1.2.6'
+gem 'tmail'
+gem 'i18n'
+gem 'activesupport', '3.0.9'
+gem 'sinatra_more', "~> 0.3.43"
+gem 'haml', "~> 3.1.1"
+gem 'net-sftp', "~> 2.0.5"
+gem 'warden', "~> 1.0.4"
+gem 'nokogiri'
+gem 'yajl-ruby'

data/README.rdoc

@@ -0,0 +1,47 @@
+== RottenEgg
+
+RottenEgg is a tool to upload SCM(svn|git) files via FTP.
+
+== Required ruby version
+
+~>= 1.8.7
+
+== Installation
+For <b>Non-Windows</b> install
+    gem install rottenegg
+
+For <b>Windows</b> install,maybe need DevelopmentKit[https://github.com/oneclick/rubyinstaller/wiki/Development-Kit], follow the instructions.
+    install thin:
+        gem install rack
+        gem install eventmachine
+        gem install thin --platform=mswin32
+    install tmail:
+        gem install tmail
+    finally:
+        gem install rottenegg
+
+== Getting Started
+
+First, make sure you can use <b>git</b> or <b>svn</b> command under the console.
+
+=== 1. Generate the config file
+
+    rottenegg_gen git
++or+
+    rottenegg_gen svn
+
+Then update the configuration you want.
+
+=== 2. Generate the auth file for login user
+
+    rottenegg_gen auth
+
+If skip this step, will default 'rotten' and 'egg' as login user and password.
+
+=== 3. Start & Scroll
+
+rottenegg -h for help.
+
+    rottenegg -C path/to/config.yml -A path/to/auth.yml -W path/to/working_directory
+
+http://localhost:14720/login

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/bin/rottenegg

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+
+require 'rotten_egg'
+RottenEgg::Server.start

data/bin/rottenegg_gen

@@ -0,0 +1,55 @@
+#!/usr/bin/env ruby
+INTRO =<<_PLAIN_
+# name is unique!
+# scm(svn).sanitize_path_prefix split with '|'
+_PLAIN_
+
+SVN =<<_YAML_
+scm:
+  tool: svn
+  repository: /path/to/repository
+  sanitize_path_prefix: /repos/projects/release/|/some/path/projects/trunk/
+  remote_version_file: ftproot/path/to/version.txt
+#  username: svn_account
+#  password: svn_password
+_YAML_
+
+GIT =<<_YAML_
+scm:
+  tool: git
+  branch: master
+  repository: /path/to/repository
+  remote_version_file: ftproot/path/to/version.txt
+_YAML_
+
+FTP =<<_YAML_
+ftp:
+    host: www.examples.com
+    port: 21
+    user: username
+    password: password
+    passive: false
+    verbose: true
+name: rottenegg
+_YAML_
+
+AUTH =<<_AUTH_
+user: name
+password: password
+_AUTH_
+
+case ARGV.join
+  when "svn"
+    section = "config"
+    File.open("#{ENV["PWD"]}/#{section}.yml", "w") { |f| f.write(INTRO + SVN + FTP)  }
+  when "git"
+    section = "config"
+    File.open("#{ENV["PWD"]}/#{section}.yml", "w") { |f| f.write(INTRO + GIT + FTP)  }
+  when "auth"
+    section = "auth"
+    File.open("#{ENV["PWD"]}/#{section}.yml", "w") { |f| f.write AUTH  }
+  else
+    abort "'#{__FILE__}' need one of [git|svn|auth]"
+end
+
+puts "#{ENV["PWD"]}/#{section}.yml generated!"

data/lib/rotten_egg.rb

@@ -0,0 +1,14 @@
+# encoding: utf-8
+require 'rubygems' unless defined? Gem
+
+module RottenEgg
+
+  autoload :AppSetting,       File.expand_path('../rotten_egg/app_setting',     __FILE__)
+  autoload :MessageLogger,    File.expand_path('../rotten_egg/message_logger',  __FILE__)
+  autoload :Scm,              File.expand_path('../rotten_egg/scm',             __FILE__)
+  autoload :Util,             File.expand_path('../rotten_egg/util',            __FILE__)
+  autoload :User,             File.expand_path('../rotten_egg/user',            __FILE__)
+  autoload :Application,      File.expand_path('../rotten_egg/application',     __FILE__)
+  autoload :Server,           File.expand_path('../rotten_egg/server',          __FILE__)
+
+end

data/lib/rotten_egg/app_setting.rb

@@ -0,0 +1,76 @@
+# encoding: utf-8
+
+require 'yaml'
+
+class Hash
+  #take keys of hash and transform those to a symbols
+  def self.transform_keys_to_symbols(value)
+    return value if not value.is_a?(Hash)
+    hash = value.inject({}) { |memo, (k, v)| memo[k.to_sym] = Hash.transform_keys_to_symbols(v); memo }
+    return hash
+  end
+end
+
+module RottenEgg
+  class AppSetting
+
+    def self.parse!(config, is_file = false)
+
+      setting_hash = is_file ? YAML::load_file(config) : YAML::load(config)
+      setting      = Hash.transform_keys_to_symbols(setting_hash)
+
+      setting.update(:name => "rotten_egg") unless setting[:name]
+
+      raise "Scm is not in set." unless setting[:scm]
+      # only support git and svn
+      raise "Scm tools support [#{Scm::TOOLS.join("|")}]" unless Scm::TOOLS.include? setting[:scm][:tool]
+
+      # Locate scm tool bin path
+      scm_bin_path = Util.check_scm setting[:scm][:tool]
+      setting[:scm].update(scm_bin_path)
+
+      # Git repos branch default(master)
+      setting[:scm].update(:branch => "master") unless setting[:scm][:branch] if setting[:scm][:tool] == "git"
+
+      # Svn user and password
+      if setting[:scm][:user] and setting[:scm][:password]
+        setting[:scm].update(:authorize => true)
+      else
+        setting[:scm].update(:authorize => false)
+      end if setting[:scm][:tool] == "svn"
+
+      raise "Scm svn sanitize path prefix is missing" unless setting[:scm][:sanitize_path_prefix] if setting[:scm][:tool] == "svn"
+
+      raise "Scm repository path is not in set." unless setting[:scm][:repository]
+
+      setting[:scm][:repository] = Util.format_path(setting[:scm][:repository])
+
+      # Although 'svn' commands support REPOS_URL, but in this case we need local repos
+      raise "Scm repository path('#{setting[:scm][:repository]}') not exist, please check the given path exist." unless File.directory? setting[:scm][:repository]
+
+      raise "Remote scm version file missing." unless setting[:scm][:remote_version_file]
+
+      # FTP setting check
+      raise "Ftp is not in set." unless setting[:ftp]
+
+      #setting[:ftp].update(:use_sftp => %w(yes true).include?(setting[:ftp][:use_sftp]))
+      setting[:ftp].update(:passive => %w(yes true).include?(setting[:ftp][:passive]))
+
+      raise "Ftp host is not in set." unless setting[:ftp][:host]
+
+      # Ftp default port 21
+      setting[:ftp].update(:port => 21) unless setting[:ftp][:port]
+      raise "Ftp user is not in set." unless setting[:ftp][:user]
+
+      if setting[:ftp][:user] == "anonymous"
+        setting[:ftp].update(:password => nil)
+      else
+        raise "Ftp password is not in set." unless setting[:ftp][:password]
+      end
+
+      setting
+    end # - parse!
+
+  end # - AppSetting
+
+end # - RottenEgg

data/lib/rotten_egg/application.rb

@@ -0,0 +1,299 @@
+# encoding: utf-8
+
+require 'yaml'
+require 'sinatra'
+gem 'activesupport', '3.0.9'
+require "active_support"
+require 'sinatra_more'
+require 'haml'
+require 'yajl/json_gem'
+
+APP_ROOT  = File.expand_path(File.join(File.dirname(__FILE__), '../..'))
+
+module RottenEgg
+  class Application < Sinatra::Base
+
+    set :root, APP_ROOT
+    set :app_name, "Rotten egg"
+    set :changed_entries, []
+    set :ftp_utils, {}
+    set :msg_logger, MessageLogger.new
+    set :running_status, false
+
+    if development?
+      reset!
+#      use Rack::Lint
+      use Rack::Reloader, 0
+      use Rack::CommonLogger
+    end
+
+    # secret => rand(16**64).to_s(16)
+    use Rack::Session::Cookie, :key => 'rotten.egg.session',
+                               :path => '/',
+                               :expire_after => 30 * 24 * 3600,
+                               :secret => '6e4b1a7b6328a6175b93b7c95ea75b8356f4f30e37b9d06c23d72d1244a5a9aa'
+
+    #cregister Sinatra::RespondTo
+
+    register SinatraMore::MarkupPlugin
+    register SinatraMore::RenderPlugin
+    register SinatraMore::WardenPlugin
+    SinatraMore::WardenPlugin::PasswordStrategy.user_class = User
+
+    configure do;end
+
+    helpers do
+      def hash_to_tree_store(value)
+        return value unless value.is_a?(Hash)
+        result = value.inject([]) do |memo, (k,v)|
+          if v.is_a?(Hash)
+            memo << { :text => k, :cls => "folder", :children => hash_to_tree_store(v) }
+          else
+            memo << { :text => "#{k}: #{(k == :password) ? '******' : v}", :leaf => true, :cls => "file" }
+          end
+          memo
+        end
+        result
+      end
+
+      def who_is_running()
+        who = ''
+        settings.apps_setting.each do |key, setting|
+           if setting[:running] == true
+              who = key.to_s
+              break
+           end
+        end
+        who
+      end
+    end
+
+    before do
+      routes = %w(/login /authenticate /logout)
+      reg_exps = routes.collect { |route| %r(\A#{route}) }
+      filters = reg_exps.reject { |exp| (exp =~ request.path).nil? ? true : false }
+      if filters.empty?
+        redirect '/login' unless authenticated?
+      end
+    end
+
+    get '/' do
+      haml :index
+    end
+
+    get '/login/?' do
+      haml_template 'session/login'
+    end
+
+#    post '/unauthenticated' do
+#      respond_to do |format|
+#        format.html {}
+#        format.json {}
+#      end
+#    end
+
+    post '/authenticate/?' do
+      content_type :json, :charset => 'utf-8'
+      if User.auth?(params[:username], params[:password])
+        authenticate_user!
+        {:success => true, :msg => "logged in"}.to_json
+      else
+        {:msg => "login failed"}.to_json
+      end
+    end
+
+    get '/logout/?' do
+      logout_user!
+      redirect '/login'
+    end
+
+    get '/apps_list/?' do
+      content_type :json, :charset => 'utf-8'
+      hash_to_tree_store(settings.apps_setting).to_json
+    end
+
+    get '/files/?' do
+      mode, status = params[:action_mode], params[:status]
+      changes = if settings.changed_entries.empty?
+                  []
+                else
+                  case mode
+                    when "M", "A", "D"
+                      settings.changed_entries.collect { |item| item[:action] == mode ? item : nil }.compact
+                    else
+                      settings.changed_entries
+                  end
+                end
+      changes = if changes.empty?# unless
+                  []
+                else
+                  case status
+                    when "pending", "success", "failed"
+                      changes.collect { |item| item[:status] == status.to_sym ? item : nil }.compact
+                    else
+                      changes
+                  end
+                end
+
+      paging_column = changes.each_slice(settings.paging_size).collect { |files| files }
+      page = params[:page].to_i
+      if page <= 1
+        page = 1
+      elsif page >= paging_column.size
+        page = paging_column.size
+      end
+      page = page - 1
+      content_type :json, :charset => 'utf-8'
+      { :success => true, :files => paging_column[page], :total => changes.size }.to_json
+    end
+
+    get '/logs?' do
+      #content_type :html, :charset => 'utf-8'
+      haml settings.msg_logger.pop_all.reverse.join("\n"), :layout => false
+    end
+
+    get '/running_status?' do
+      haml settings.running_status.to_s, :layout => false
+    end
+
+    get '/turnoff' do
+      settings.running_status = false
+      settings.apps_setting.each do |key, setting|
+        setting.update(:running => false)
+        settings.ftp_utils[key] = nil
+      end
+      settings.changed_entries.clear
+      settings.msg_logger.clear!
+      haml 'ok', :layout => false
+    end
+
+    # http://www.sencha.com/forum/archive/index.php/t-120201.html
+    # http://stackoverflow.com/questions/4859502/upload-files-by-extjs-ajax-request-and-asp-net-mvc-without-reload-page-ajax-styl
+    post '/cfg_upload/?' do
+      # specify content_type to 'text/html' , resolved ''<pre style="word-wrap: break-word; white-space: pre-wrap;">{"success":false,"msg":"Failed to add request"}</pre>' error message.
+      content_type :html, :charset => 'utf-8'
+      result = begin
+        yml_file                     = params["file_path"][:tempfile].read
+        setting                      = AppSetting.parse!(yml_file)
+        name                         = setting.delete(:name)
+        if settings.apps_setting[name] && settings.apps_setting[name][:running] == true
+          { :success => true, :egg => 0, :msg => "The app [#{name}] is running, please try upload later." }
+        else
+          settings.apps_setting[name] = setting
+          { :success => true, :egg => 1, :msg => "ok" }
+        end
+      rescue Exception => e
+        { :success => true, :egg => 2, :msg => e.message }
+      end
+
+      haml result.to_json
+    end
+
+    get '/rm_app/?' do
+      content_type :html, :charset => 'utf-8'
+      result = begin
+        if settings.apps_setting[params[:name]] && settings.apps_setting[params[:name]][:running] == true
+          { :egg => "running", :msg => "#{params[:name]} is running, please try later." }
+        else
+          settings.apps_setting.delete params[:name]
+          { :egg => "ok", :msg => "#{params[:name]} remove successfully." }
+        end
+      rescue Exception => e
+        { :egg => "error", :msg => e.message }
+      end
+      haml result.to_json, :layout => false
+    end
+
+    get '/run_app' do
+      content_type :html, :charset => 'utf-8'
+      if settings.running_status == true
+        result = {:egg => "running", :msg => "That's a thread[#{who_is_running}] is running, please try later."}
+      else
+        result = begin
+          app_setting = settings.apps_setting[params[:name]]
+          if app_setting
+            if app_setting[:running] == true
+              {:egg => "running", :msg => "#{params[:name]} is running, please try later."}
+            else
+
+              settings.changed_entries.clear
+              settings.ftp_utils.delete params[:name]
+
+              ftp_util = settings.ftp_utils[params[:name]] = Util::FtpTool.new(
+                  app_setting[:ftp][:host],
+                  app_setting[:ftp][:port],
+                  app_setting[:ftp][:user],
+                  app_setting[:ftp][:password],
+                  :msg_logger => settings.msg_logger,
+                  :passive => app_setting[:ftp][:passive],
+                  :verbose => production?
+              )
+              settings.msg_logger.clear!
+
+              # begin running
+              app_setting.update(:running => true)
+              settings.running_status = true
+
+              dld_ver_status = ftp_util.download_version_file(settings.working_directory, app_setting[:scm][:remote_version_file])
+              status = case dld_ver_status
+                         when :initial
+                           app_setting[:scm].update(:remote_commit => nil)
+                         when :success
+                           if File.exist?(settings.working_directory + app_setting[:scm][:remote_version_file])
+                             app_setting[:scm].update(:remote_commit => File.read(settings.working_directory + app_setting[:scm][:remote_version_file]).chomp)
+                             true
+                           else
+                             false
+                           end
+                         else # :failure, :ftp_connect_failure
+                           false
+                       end
+              if status
+                settings.changed_entries = Scm.get_changes(app_setting[:scm])
+                puts "goes here"
+                if settings.changed_entries.empty?
+                  app_setting.update(:running => false)
+                  settings.running_status = false
+                  {:egg => "empty", :msg => "no files has been changed"}
+                else
+                  # fork {}
+                  Thread.fork {
+                    result = ftp_util.apply_changes(app_setting[:scm][:repository], settings.changed_entries)
+                    if result
+                      File.open(settings.working_directory + app_setting[:name] + "_latest_version.txt", "w") { |f| f.write(app_setting[:scm][:latest_commit]) }
+                      upload_version_file_status = ftp_util.update_version_file settings.working_directory + app_setting[:name] + "_latest_version.txt", app_setting[:scm][:remote_version_file]
+                    end
+                    if upload_version_file_status
+                      settings.changed_entries.clear
+                      settings.msg_logger.clear!
+                    end
+                    app_setting.update(:running => false)
+                    settings.running_status = false
+
+                  }
+                  puts "goes rotten"
+                  {:egg => "rotten", :msg => "running..."}
+                end
+              else
+                app_setting.update(:running => false)
+                settings.running_status = false
+                {:egg => 'failure', :msg => "download remove version file failed"}
+              end
+            end
+          else
+            app_setting.update(:running => false)
+            settings.running_status = false
+            {:egg => "missing", :msg => "#{params[:name]} not exist"}
+          end # config setting exist
+        rescue Exception => e
+          app_setting.update(:running => false)
+          settings.running_status = false
+          {:egg => "error", :msg => e.message}
+        end
+      end
+
+      haml result.to_json, :layout => false      
+    end
+
+  end
+end