resque_manager 3.3.0

data/lib/resque_manager/recipes.rb

@@ -0,0 +1,185 @@
+# ====================================
+# Resque TASKS
+# ====================================
+
+#You must set the path to your rake executable in your deploy.rb file.
+#ex.
+# set :rake, "/opt/ruby-enterprise-1.8.6-20090421/bin/rake"
+#Optionally, set resque_worker_rake.  This will be used for the resque:work task if set.
+#This allows you to set alternate options, particularly useful for jruby.
+#ex.
+#go through jexec so we get the right path and java settings
+#in deploy.rb
+# set :rake, "script/jexec rake" #
+# in initializer
+# config.resque_worker_rake = "script/jexec -p rake" #extra memory settings for resque workers
+
+#the jexec file in script/ may look like:
+
+#scriptdir=`dirname $0`
+#
+## Hack to get things working under capistrano (used for torquebox to get rake working, still needed?)
+#if [ "$1" = "-j" ]; then
+#    shift
+#    export JRUBY_HOME=$1
+#    shift
+#fi
+#
+#if [ "$1" = "-m" ]; then
+#        shift
+#        export JAVA_MEM="-Xmx2048m -Xms256m -XX:PermSize=1024m -XX:MaxPermSize=1024m"
+#        export JAVA_STACK=-Xss4096k
+#fi
+#
+#export PATH=$scriptdir:/opt/jruby/bin:$PATH
+#
+## Configuration settings for all Rake Tasks and Resque Workers
+#if [ "$1" = "-p" ]; then
+#        shift
+#        # Set Heap Space for Young/Eden GC: 512MB
+#        # Initial Heap size: 2GB
+#        # Max Heap size: 4GB
+#        # Use server JVM
+#        # PermGenSize: 64MB
+#        # Max PermGenSize: 128MB
+#        # Thread Stack Size: 1024k
+#        export JRUBY_OPTS="-J-Xmn512m -J-Xms2048m -J-Xmx4096m -J-server -J-XX:PermSize=64m -J-XX:MaxPermSize=128m -J-Xss1024k"
+#        echo "JRUBY_OPTS=${JRUBY_OPTS}"
+#        nohup $* & #cap task runs in background
+#else
+#        exec $*
+#fi
+
+Capistrano::Configuration.instance(:must_exist).load do
+
+  set :resque_worker_rake, nil # initialize variables, set in your deploy.rb
+  set :resque_applications, nil # initialize variables, set in your deploy.rb
+
+  def get_rake
+    fetch(:resque_worker_rake, fetch(:rake, "rake"))
+  end
+
+  def get_worker_path
+    (ENV['application_path'].to_s.size > 0) ? ENV['application_path'] : current_path
+  end
+
+  namespace :resque do
+    desc "start a resque worker. optional arg: host=ip queue=name"
+    task :work, :roles => :resque do
+      default_run_options[:pty] = true
+      hosts = ENV['host'] || find_servers_for_task(current_task).collect { |s| s.host }
+      queue = ENV['queue'] || '*'
+      rake = get_rake
+      run("cd #{get_worker_path}; nohup #{rake} RAILS_ENV=#{stage} QUEUE=#{queue} resque:work >> log/resque_worker.log 2>&1", :hosts => hosts)
+    end
+
+    desc "Gracefully kill a worker.  If the worker is working, it will finish before shutting down. arg: host=ip pid=pid"
+    task :quit_worker, :roles => :resque do
+      if ENV['host'].nil? || ENV['host'].empty? || ENV['pid'].nil? || ENV['pid'].empty?
+        puts 'You must enter the host and pid to kill..cap resque:quit_worker host=ip pid=pid'
+      else
+        #The kill command used to be done directly in the cap task, but since workers can now live in multiple apps, we need to send
+        #the correct signal based on the worker's platform which has to be done in the rake task."
+        hosts = ENV['host'] || find_servers_for_task(current_task).collect { |s| s.host }
+        run("cd #{get_worker_path}; nohup #{get_rake} RAILS_ENV=#{stage} resque:quit_worker pid=#{ENV['pid']}", :hosts => hosts)
+      end
+    end
+
+    desc "Pause all workers in a single process. arg: host=ip pid=pid"
+    task :pause_worker, :roles => :resque do
+      if ENV['host'].nil? || ENV['host'].empty? || ENV['pid'].nil? || ENV['pid'].empty?
+        puts'You must enter the host and pid to kill..cap resque : pause_worker host=ip pid=pid'
+      else
+        hosts = ENV['host'] || find_servers_for_task(current_task).collect { |s| s.host }
+        run("kill -USR2 #{ENV['pid']}", :hosts => hosts)
+      end
+    end
+
+    desc "Continue all workers in a single process that have been paused. arg: host=ip pid=pid"
+    task :continue_worker, :roles => :resque do
+      if ENV['host'].nil? || ENV['host'].empty? || ENV['pid'].nil? || ENV['pid'].empty?
+        puts'You must enter the host and pid to kill..cap resque : continue_worker host=ip pid=pid'
+      else
+        hosts = ENV['host'] || find_servers_for_task(current_task).collect { |s| s.host }
+        run("kill -CONT #{ENV['pid']}", :hosts => hosts)
+      end
+    end
+
+    desc "Gracefully kill all workers on all servers.  If the worker is working, it will finish before shutting down."
+    task :quit_workers, :roles => :resque do
+      default_run_options[:pty] = true
+      rake = fetch(:rake, "rake")
+      run("cd #{get_worker_path}; #{rake} RAILS_ENV=#{stage} resque:quit_workers")
+    end
+
+    desc "Kill a rogue worker.  If the worker is working, it will not finish and the job will go to the Failed queue as a DirtyExit. arg: host=ip pid=pid"
+    task :kill_worker_with_impunity, :roles => :resque do
+      if ENV['host'].nil? || ENV['host'].empty? || ENV['pid'].nil? || ENV['pid'].empty?
+        puts'You must enter the host and pid to kill..cap resque : quit host=ip pid=pid'
+      else
+        hosts = ENV['host'] || find_servers_for_task(current_task).collect { |s| s.host }
+        run("kill -9 #{ENV['pid']}", :hosts => hosts)
+      end
+    end
+
+    desc "Kill all rogue workers on all servers.  If the worker is working, it will not finish and the job will go to the Failed queue as a DirtyExit."
+    task :kill_workers_with_impunity, :roles => :resque do
+      default_run_options[:pty] = true
+      rake = fetch(:rake, "rake")
+      run("cd #{get_worker_path}; #{rake} RAILS_ENV=#{stage} resque:kill_workers_with_impunity")
+    end
+
+    desc "start multiple resque workers. arg:count=x optional arg: host=ip queue=name"
+    task :workers, :roles => :resque do
+      default_run_options[:pty] = true
+      hosts = ENV['host'] || find_servers_for_task(current_task).collect { |s| s.host }
+      queue = ENV['queue'] ||'*'
+      count = ENV['count'] ||'1'
+      rake = get_rake
+      run("cd #{get_worker_path}; nohup #{rake} RAILS_ENV=#{stage} COUNT=#{count} QUEUE=#{queue} resque:work >> log/resque_worker.log 2>&1", :hosts => hosts)
+    end
+
+    desc "Restart all workers on all servers"
+    task :restart_workers, :roles => :resque do
+      default_run_options[:pty] = true
+      rake = fetch(:rake, "rake")
+      #pass the rake options to the rake task so the workers can be started with the options.
+      run("cd #{get_worker_path}; RAILS_ENV=#{stage} RAKE_WITH_OPTS='#{get_rake}'nohup #{rake} resque:restart_workers")
+      end
+
+      # ====================================
+      # ResqueScheduler TASKS
+      # ====================================
+
+      desc "start a resque worker. optional arg: host=ip queue=name"
+      task :scheduler, :roles => :resque do
+        default_run_options[:pty] = true
+        hosts = ENV['host'] || find_servers_for_task(current_task).collect { |s| s.host }
+        rake = fetch(:rake, "rake")
+        run("cd #{get_worker_path}; nohup #{rake} RAILS_ENV=#{stage} resque:scheduler", :hosts => hosts)
+      end
+
+      desc "Gracefully kill the scheduler on a server. arg: host=ip"
+      task :quit_scheduler, :roles => :resque do
+        if ENV['host'].nil? || ENV['host'].empty?
+          puts'You must enter the host to kill..cap resque:quit_scheduler host=ip pid=pid'
+        else
+          hosts = ENV['host'] || find_servers_for_task(current_task).collect { |s| s.host }
+          rake = fetch(:rake, "rake")
+          run("cd #{get_worker_path}; nohup #{rake} RAILS_ENV=#{stage} resque:quit_scheduler", :hosts => hosts)
+        end
+      end
+
+      desc "Determine if the scheduler is running or not on a server"
+      task :scheduler_status, :roles => :resque do
+        hosts = ENV['hosts'].to_s.split(',') || find_servers_for_task(current_task).collect { |s| s.host }
+
+        status = nil
+
+        run("ps -eaf | grep resque | grep -v cap", :hosts => hosts) do |channel, stream, data|
+          status = (data =~ /resque:scheduler/) ? 'up' : 'down'
+          puts " ** [#{stream} :: #{channel[:host]}] resque:scheduler is #{status}"
+        end
+      end
+    end
+  end

data/lib/resque_manager/version.rb

@@ -0,0 +1,3 @@
+module ResqueManager
+  VERSION = "3.3.0"
+end

data/lib/resque_manager.rb

@@ -0,0 +1,47 @@
+require "resque_manager/engine"
+require 'resque/server'
+require 'resque_manager/overrides/resque/worker'
+require 'resque_manager/overrides/resque/resque'
+require 'resque_manager/overrides/resque/job'
+require 'resque_manager/overrides/resque/failure/redis'
+if Resque.respond_to? :schedule
+  require 'resque_scheduler/tasks'
+  require 'resque_manager/overrides/resque_scheduler/resque_scheduler'
+end
+require 'resque-status'
+require 'resque_manager/overrides/resque_status/status'
+require 'resque_manager/overrides/resque_status/chained_status'
+require 'resque-cleaner'
+
+Resque::Server.tabs << 'Statuses'
+Resque::Server.tabs.delete 'Failed'
+
+module ResqueManager
+  # Set this to a hash of all the different applications and deployment paths
+  # for those applications that have workers you want to manage.
+  # The different app do not have to be deployed to the same server.
+  # ex. {app1: 'www/var/rails/app1/current',
+  #      app2: 'www/var/rails/app2/current'}
+  # There is no need to set this if all the workers live in the same app as the Resque Manager
+  # It will default to the current app's deploy path
+  mattr_accessor :applications
+  @@applicataions = nil
+
+  mattr_accessor :redis_config
+  @@redis_config = "SET TO RESQUE'S REDIS CONFIGURATION HASH"
+
+  # Optionally set this to when you want to expire the resque keys.
+  mattr_accessor :key_expiration
+  @@key_expiration = nil
+
+  # Optionally set this to determine whether to run inline or not.
+  mattr_accessor :inline
+  @@inline
+
+  def self.configure
+    yield self
+    Resque.redis = Redis.new(redis_config)
+    Resque::Plugins::Status::Hash.expire_in = key_expiration
+    Resque.inline = inline
+  end
+end

data/lib/tasks/failure.rake

@@ -0,0 +1,8 @@
+namespace :resque do
+
+  desc "Requeue all failed jobs in a class.  If no class is given, all failed jobs will be requeued. ex: rake resque:requeue class=class_name"
+  task :requeue => :setup do
+    Resque::Failure.requeue ENV['class']
+  end
+
+end

data/lib/tasks/scheduler.rake

@@ -0,0 +1,11 @@
+namespace :resque do
+
+  desc "Kill the scheduler pid"
+  task :quit_scheduler => :setup do
+    require 'resque_scheduler'
+    ResqueScheduler.pids.each do |pid|
+      `kill -TERM #{pid}`
+    end
+  end
+
+end

data/lib/tasks/worker.rake

@@ -0,0 +1,129 @@
+namespace :resque do
+
+  desc "Start a Resque worker, each queue will create it's own worker in a separate thread"
+  task :work => :setup do
+    require 'resque'
+
+    worker = nil
+    queues = (ENV['QUEUES'] || ENV['QUEUE']).to_s.split('#').delete_if { |a| a.blank? }
+    threads = []
+    mqueue = queues.shift
+    # we are assuming the application has been deployed with a standard cap recipe.
+    base, version = Rails.root.to_s.split('/releases')
+    worker_path = base
+    # add current to the path to use the symlink used by a standard cap deploy
+    # unless the app is deployed to the "current" directory when using cap-git-deploy
+    worker_path += '/current' unless Rails.env.development? || worker_path =~ /current/
+    Thread.current[:queues] = mqueue
+    Thread.current[:path] = worker_path
+    mworker = Resque::Worker.new(mqueue)
+    mworker.verbose = true #ENV['LOGGING'] || ENV['VERBOSE']
+    mworker.very_verbose = true #ENV['VVERBOSE']
+
+    if ENV['PIDFILE']
+      File.open(ENV['PIDFILE'], 'w') { |f| f << mworker.pid }
+    end
+
+    queues.each do |queue|
+      threads << Thread.new do
+        begin
+          Thread.current[:queues] = queue
+          Thread.current[:path] = worker_path
+          worker = Resque::Worker.new(queue)
+          worker.verbose = ENV['LOGGING'] || ENV['VERBOSE']
+          worker.very_verbose = ENV['VVERBOSE']
+        rescue Resque::NoQueueError
+          abort "set QUEUE env var, e.g. $ QUEUE=critical,high rake resque:work"
+        end
+
+        worker.log "Starting worker #{worker}"
+        begin
+          worker.work(ENV['INTERVAL'] || 5) # interval, will block
+        rescue Exception => e
+          puts "********** e.message = " + e.message.inspect
+          Rails.logger.info "********** e.message = " + e.message.inspect
+        end
+      end
+    end
+    threads.each { |thread| thread.join(0.5) }
+    mworker.work(ENV['INTERVAL'] || 5) # interval, will block
+  end
+
+  desc "Restart all the workers"
+  task :restart_workers => :setup do
+    require 'resque'
+    pid = ''
+    queues = ''
+    local_ip = Resque.workers.first.local_ip rescue '';
+    rake = ENV['RAKE_WITH_OPTS'] || 'rake'
+    Resque.workers.sort_by { |w| w.to_s }.each do |worker|
+      if local_ip == worker.ip # only restart the workers that are on this server
+        if pid != worker.pid
+          if RUBY_PLATFORM =~ /java/
+            #jruby doesn't trap the -QUIT signal
+            #-TERM gracefully kills the main pid and does a -9 on the child if there is one.
+            #Since jruby doesn't fork a child, the main worker is gracefully killed.
+            system("kill -TERM  #{worker.pid}")
+          else
+            system("kill -QUIT  #{worker.pid}")
+          end
+          queues = worker.queues_in_pid.join('#')
+          Thread.new(queues) { |queue| system("nohup #{rake} RAILS_ENV=#{Rails.env} QUEUE=#{queue} resque:work") }
+          pid = worker.pid
+        end
+      end
+    end
+  end
+
+  desc "Gracefully kill a single worker.  If the worker is working, it will finish before shutting down. arg: pid=pid
+       This used to be done directly in the cap task, but since workers can now live in multiple apps, we need to send
+       the correct signal based on the worker's platform."
+  task :quit_worker => :setup do
+    if RUBY_PLATFORM =~ /java/
+      #jruby doesn't trap the -QUIT signal
+      #-TERM gracefully kills the main pid and does a -9 on the child if there is one.
+      #Since jruby doesn't fork a child, the main worker is gracefully killed.
+      system("kill -TERM  #{ENV['pid']}")
+    else
+      system("kill -QUIT  #{ENV['pid']}")
+    end
+  end
+
+  desc "Gracefully kill all the workers.  If the worker is working, it will finish before shutting down."
+  task :quit_workers => :setup do
+    require 'resque'
+    pid = ''
+    local_ip = Resque.workers.first.local_ip
+    Resque.workers.sort_by { |w| w.to_s }.each do |worker|
+      if local_ip == worker.ip # only quit the workers that are on this server
+        if pid != worker.pid
+          if RUBY_PLATFORM =~ /java/
+            #jruby doesn't trap the -QUIT signal
+            #-TERM gracefully kills the main pid and does a -9 on the child if there is one.
+            #Since jruby doesn't fork a child, the main worker is gracefully killed.
+            system("kill -TERM  #{worker.pid}")
+          else
+            system("kill -QUIT  #{worker.pid}")
+          end
+          pid = worker.pid
+        end
+      end
+    end
+  end
+
+  desc "Kill all rogue workers on all servers.  If the worker is working, it will not finish and the job will go to the Failed queue as a DirtExit. arg: host=ip pid=pid"
+  task :kill_workers_with_impunity => :setup do
+    require 'resque'
+    pid = ''
+    local_ip = Resque.workers.first.local_ip
+    Resque.workers.sort_by { |w| w.to_s }.each do |worker|
+      if local_ip == worker.ip # only kill the pids that are on this server
+        if pid != worker.pid # only kill it once
+          `kill -9 #{worker.pid}`
+          pid = worker.pid
+        end
+      end
+    end
+  end
+
+end

data/test/dummy/README.rdoc

@@ -0,0 +1,261 @@
+== Welcome to Rails
+
+Rails is a web-application framework that includes everything needed to create
+database-backed web applications according to the Model-View-Control pattern.
+
+This pattern splits the view (also called the presentation) into "dumb"
+templates that are primarily responsible for inserting pre-built data in between
+HTML tags. The model contains the "smart" domain objects (such as Account,
+Product, Person, Post) that holds all the business logic and knows how to
+persist themselves to a database. The controller handles the incoming requests
+(such as Save New Account, Update Product, Show Post) by manipulating the model
+and directing data to the view.
+
+In Rails, the model is handled by what's called an object-relational mapping
+layer entitled Active Record. This layer allows you to present the data from
+database rows as objects and embellish these data objects with business logic
+methods. You can read more about Active Record in
+link:files/vendor/rails/activerecord/README.html.
+
+The controller and view are handled by the Action Pack, which handles both
+layers by its two parts: Action View and Action Controller. These two layers
+are bundled in a single package due to their heavy interdependence. This is
+unlike the relationship between the Active Record and Action Pack that is much
+more separate. Each of these packages can be used independently outside of
+Rails. You can read more about Action Pack in
+link:files/vendor/rails/actionpack/README.html.
+
+
+== Getting Started
+
+1. At the command prompt, create a new Rails application:
+       <tt>rails new myapp</tt> (where <tt>myapp</tt> is the application name)
+
+2. Change directory to <tt>myapp</tt> and start the web server:
+       <tt>cd myapp; rails server</tt> (run with --help for options)
+
+3. Go to http://localhost:3000/ and you'll see:
+       "Welcome aboard: You're riding Ruby on Rails!"
+
+4. Follow the guidelines to start developing your application. You can find
+the following resources handy:
+
+* The Getting Started Guide: http://guides.rubyonrails.org/getting_started.html
+* Ruby on Rails Tutorial Book: http://www.railstutorial.org/
+
+
+== Debugging Rails
+
+Sometimes your application goes wrong. Fortunately there are a lot of tools that
+will help you debug it and get it back on the rails.
+
+First area to check is the application log files. Have "tail -f" commands
+running on the server.log and development.log. Rails will automatically display
+debugging and runtime information to these files. Debugging info will also be
+shown in the browser on requests from 127.0.0.1.
+
+You can also log your own messages directly into the log file from your code
+using the Ruby logger class from inside your controllers. Example:
+
+  class WeblogController < ActionController::Base
+    def destroy
+      @weblog = Weblog.find(params[:id])
+      @weblog.destroy
+      logger.info("#{Time.now} Destroyed Weblog ID ##{@weblog.id}!")
+    end
+  end
+
+The result will be a message in your log file along the lines of:
+
+  Mon Oct 08 14:22:29 +1000 2007 Destroyed Weblog ID #1!
+
+More information on how to use the logger is at http://www.ruby-doc.org/core/
+
+Also, Ruby documentation can be found at http://www.ruby-lang.org/. There are
+several books available online as well:
+
+* Programming Ruby: http://www.ruby-doc.org/docs/ProgrammingRuby/ (Pickaxe)
+* Learn to Program: http://pine.fm/LearnToProgram/ (a beginners guide)
+
+These two books will bring you up to speed on the Ruby language and also on
+programming in general.
+
+
+== Debugger
+
+Debugger support is available through the debugger command when you start your
+Mongrel or WEBrick server with --debugger. This means that you can break out of
+execution at any point in the code, investigate and change the model, and then,
+resume execution! You need to install ruby-debug to run the server in debugging
+mode. With gems, use <tt>sudo gem install ruby-debug</tt>. Example:
+
+  class WeblogController < ActionController::Base
+    def index
+      @posts = Post.all
+      debugger
+    end
+  end
+
+So the controller will accept the action, run the first line, then present you
+with a IRB prompt in the server window. Here you can do things like:
+
+  >> @posts.inspect
+  => "[#<Post:0x14a6be8
+          @attributes={"title"=>nil, "body"=>nil, "id"=>"1"}>,
+       #<Post:0x14a6620
+          @attributes={"title"=>"Rails", "body"=>"Only ten..", "id"=>"2"}>]"
+  >> @posts.first.title = "hello from a debugger"
+  => "hello from a debugger"
+
+...and even better, you can examine how your runtime objects actually work:
+
+  >> f = @posts.first
+  => #<Post:0x13630c4 @attributes={"title"=>nil, "body"=>nil, "id"=>"1"}>
+  >> f.
+  Display all 152 possibilities? (y or n)
+
+Finally, when you're ready to resume execution, you can enter "cont".
+
+
+== Console
+
+The console is a Ruby shell, which allows you to interact with your
+application's domain model. Here you'll have all parts of the application
+configured, just like it is when the application is running. You can inspect
+domain models, change values, and save to the database. Starting the script
+without arguments will launch it in the development environment.
+
+To start the console, run <tt>rails console</tt> from the application
+directory.
+
+Options:
+
+* Passing the <tt>-s, --sandbox</tt> argument will rollback any modifications
+  made to the database.
+* Passing an environment name as an argument will load the corresponding
+  environment. Example: <tt>rails console production</tt>.
+
+To reload your controllers and models after launching the console run
+<tt>reload!</tt>
+
+More information about irb can be found at:
+link:http://www.rubycentral.org/pickaxe/irb.html
+
+
+== dbconsole
+
+You can go to the command line of your database directly through <tt>rails
+dbconsole</tt>. You would be connected to the database with the credentials
+defined in database.yml. Starting the script without arguments will connect you
+to the development database. Passing an argument will connect you to a different
+database, like <tt>rails dbconsole production</tt>. Currently works for MySQL,
+PostgreSQL and SQLite 3.
+
+== Description of Contents
+
+The default directory structure of a generated Ruby on Rails application:
+
+  |-- app
+  |   |-- assets
+  |   |   |-- images
+  |   |   |-- javascripts
+  |   |   `-- stylesheets
+  |   |-- controllers
+  |   |-- helpers
+  |   |-- mailers
+  |   |-- models
+  |   `-- views
+  |       `-- layouts
+  |-- config
+  |   |-- environments
+  |   |-- initializers
+  |   `-- locales
+  |-- db
+  |-- doc
+  |-- lib
+  |   |-- assets
+  |   `-- tasks
+  |-- log
+  |-- public
+  |-- script
+  |-- test
+  |   |-- fixtures
+  |   |-- functional
+  |   |-- integration
+  |   |-- performance
+  |   `-- unit
+  |-- tmp
+  |   `-- cache
+  |       `-- assets
+  `-- vendor
+      |-- assets
+      |   |-- javascripts
+      |   `-- stylesheets
+      `-- plugins
+
+app
+  Holds all the code that's specific to this particular application.
+
+app/assets
+  Contains subdirectories for images, stylesheets, and JavaScript files.
+
+app/controllers
+  Holds controllers that should be named like weblogs_controller.rb for
+  automated URL mapping. All controllers should descend from
+  ApplicationController which itself descends from ActionController::Base.
+
+app/models
+  Holds models that should be named like post.rb. Models descend from
+  ActiveRecord::Base by default.
+
+app/views
+  Holds the template files for the view that should be named like
+  weblogs/index.html.erb for the WeblogsController#index action. All views use
+  eRuby syntax by default.
+
+app/views/layouts
+  Holds the template files for layouts to be used with views. This models the
+  common header/footer method of wrapping views. In your views, define a layout
+  using the <tt>layout :default</tt> and create a file named default.html.erb.
+  Inside default.html.erb, call <% yield %> to render the view using this
+  layout.
+
+app/helpers
+  Holds view helpers that should be named like weblogs_helper.rb. These are
+  generated for you automatically when using generators for controllers.
+  Helpers can be used to wrap functionality for your views into methods.
+
+config
+  Configuration files for the Rails environment, the routing map, the database,
+  and other dependencies.
+
+db
+  Contains the database schema in schema.rb. db/migrate contains all the
+  sequence of Migrations for your schema.
+
+doc
+  This directory is where your application documentation will be stored when
+  generated using <tt>rake doc:app</tt>
+
+lib
+  Application specific libraries. Basically, any kind of custom code that
+  doesn't belong under controllers, models, or helpers. This directory is in
+  the load path.
+
+public
+  The directory available for the web server. Also contains the dispatchers and the
+  default HTML files. This should be set as the DOCUMENT_ROOT of your web
+  server.
+
+script
+  Helper scripts for automation and generation.
+
+test
+  Unit and functional tests along with fixtures. When using the rails generate
+  command, template test files will be generated for you and placed in this
+  directory.
+
+vendor
+  External libraries that the application depends on. Also includes the plugins
+  subdirectory. If the app has frozen rails, those gems also go here, under
+  vendor/rails/. This directory is in the load path.

data/test/dummy/Rakefile

@@ -0,0 +1,7 @@
+#!/usr/bin/env rake
+# Add your own tasks in files placed in lib/tasks ending in .rake,
+# for example lib/tasks/capistrano.rake, and they will automatically be available to Rake.
+
+require File.expand_path('../config/application', __FILE__)
+
+Dummy::Application.load_tasks

data/test/dummy/app/assets/javascripts/application.js

@@ -0,0 +1,15 @@
+// This is a manifest file that'll be compiled into application.js, which will include all the files
+// listed below.
+//
+// Any JavaScript/Coffee file within this directory, lib/assets/javascripts, vendor/assets/javascripts,
+// or vendor/assets/javascripts of plugins, if any, can be referenced here using a relative path.
+//
+// It's not advisable to add code directly here, but if you do, it'll appear at the bottom of the
+// the compiled file.
+//
+// WARNING: THE FIRST BLANK LINE MARKS THE END OF WHAT'S TO BE PROCESSED, ANY BLANK LINE SHOULD
+// GO AFTER THE REQUIRES BELOW.
+//
+//= require jquery
+//= require jquery_ujs
+//= require_tree .