webroar 0.2.6 → 0.3.0

data/src/admin_panel/vendor/rails/railties/lib/tasks/tmp.rake

@@ -0,0 +1,37 @@
+namespace :tmp do
+  desc "Clear session, cache, and socket files from tmp/"
+  task :clear => [ "tmp:sessions:clear",  "tmp:cache:clear", "tmp:sockets:clear"]
+
+  desc "Creates tmp directories for sessions, cache, sockets, and pids"
+  task :create do
+    FileUtils.mkdir_p(%w( tmp/sessions tmp/cache tmp/sockets tmp/pids ))
+  end
+
+  namespace :sessions do
+    desc "Clears all files in tmp/sessions"
+    task :clear do
+      FileUtils.rm(Dir['tmp/sessions/[^.]*'])
+    end
+  end
+
+  namespace :cache do
+    desc "Clears all files and directories in tmp/cache"
+    task :clear do
+      FileUtils.rm_rf(Dir['tmp/cache/[^.]*'])
+    end
+  end
+
+  namespace :sockets do
+    desc "Clears all files in tmp/sockets"
+    task :clear do
+      FileUtils.rm(Dir['tmp/sockets/[^.]*'])
+    end
+  end
+
+  namespace :pids do
+    desc "Clears all files in tmp/pids"
+    task :clear do
+      FileUtils.rm(Dir['tmp/pids/[^.]*'])
+    end
+  end
+end

data/src/admin_panel/vendor/rails/railties/lib/test_help.rb

@@ -0,0 +1,38 @@
+# Make double-sure the RAILS_ENV is set to test,
+# so fixtures are loaded to the right database
+silence_warnings { RAILS_ENV = "test" }
+
+require 'test/unit'
+require 'action_controller/test_case'
+require 'action_view/test_case'
+require 'action_controller/integration'
+require 'action_mailer/test_case' if defined?(ActionMailer)
+
+if defined?(ActiveRecord)
+  require 'active_record/test_case'
+  require 'active_record/fixtures'
+
+  class ActiveSupport::TestCase
+    include ActiveRecord::TestFixtures
+    self.fixture_path = "#{RAILS_ROOT}/test/fixtures/"
+    self.use_instantiated_fixtures  = false
+    self.use_transactional_fixtures = true
+  end
+
+  ActionController::IntegrationTest.fixture_path = ActiveSupport::TestCase.fixture_path
+
+  def create_fixtures(*table_names, &block)
+    Fixtures.create_fixtures(ActiveSupport::TestCase.fixture_path, table_names, {}, &block)
+  end
+end
+
+begin
+  require_library_or_gem 'ruby-debug'
+  Debugger.start
+  if Debugger.respond_to?(:settings)
+    Debugger.settings[:autoeval] = true
+    Debugger.settings[:autolist] = 1
+  end
+rescue LoadError
+  # ruby-debug wasn't available so neither can the debugging be
+end

data/src/admin_panel/vendor/rails/railties/lib/webrick_server.rb

@@ -0,0 +1,156 @@
+# Donated by Florian Gross
+
+require 'webrick'
+require 'cgi'
+require 'stringio'
+require 'dispatcher'
+
+include WEBrick
+
+class CGI #:nodoc:
+  def stdinput
+    @stdin || $stdin
+  end
+  
+  def env_table
+    @env_table || ENV
+  end
+  
+  def initialize(type = "query", table = nil, stdin = nil)
+    @env_table, @stdin = table, stdin
+
+    if defined?(MOD_RUBY) && !ENV.key?("GATEWAY_INTERFACE")
+      Apache.request.setup_cgi_env
+    end
+
+    extend QueryExtension
+    @multipart = false
+    if defined?(CGI_PARAMS)
+      warn "do not use CGI_PARAMS and CGI_COOKIES"
+      @params = CGI_PARAMS.dup
+      @cookies = CGI_COOKIES.dup
+    else
+      initialize_query()  # set @params, @cookies
+    end
+    @output_cookies = nil
+    @output_hidden = nil
+  end
+end
+
+# A custom dispatch servlet for use with WEBrick. It dispatches requests
+# (using the Rails Dispatcher) to the appropriate controller/action. By default,
+# it restricts WEBrick to a managing a single Rails request at a time, but you
+# can change this behavior by setting ActionController::Base.allow_concurrency
+# to true.
+class DispatchServlet < WEBrick::HTTPServlet::AbstractServlet
+  # Start the WEBrick server with the given options, mounting the
+  # DispatchServlet at <tt>/</tt>.
+  def self.dispatch(options = {})
+    Socket.do_not_reverse_lookup = true # patch for OS X
+
+    params = { :Port        => options[:port].to_i,
+               :ServerType  => options[:server_type],
+               :BindAddress => options[:ip] }
+    params[:MimeTypes] = options[:mime_types] if options[:mime_types]
+
+    server = WEBrick::HTTPServer.new(params)
+    server.mount('/', DispatchServlet, options)
+
+    trap("INT") { server.shutdown }
+    server.start
+  end
+
+  def initialize(server, options) #:nodoc:
+    @server_options = options
+    @file_handler = WEBrick::HTTPServlet::FileHandler.new(server, options[:server_root])
+    # Change to the RAILS_ROOT, since Webrick::Daemon.start does a Dir::cwd("/")
+    # OPTIONS['working_directory'] is an absolute path of the RAILS_ROOT, set in railties/lib/commands/servers/webrick.rb
+    Dir.chdir(OPTIONS['working_directory']) if defined?(OPTIONS) && File.directory?(OPTIONS['working_directory'])
+    super
+  end
+
+  def service(req, res) #:nodoc:
+    unless handle_file(req, res)
+      unless handle_dispatch(req, res)
+        raise WEBrick::HTTPStatus::NotFound, "`#{req.path}' not found."
+      end
+    end
+  end
+
+  def handle_file(req, res) #:nodoc:
+    begin
+      req = req.dup
+      path = req.path.dup
+
+      # Add .html if the last path piece has no . in it
+      path << '.html' if path != '/' && (%r{(^|/)[^./]+$} =~ path) 
+      path.gsub!('+', ' ') # Unescape + since FileHandler doesn't do so.
+
+      req.instance_variable_set(:@path_info, path) # Set the modified path...
+
+      @file_handler.send(:service, req, res)      
+      return true
+    rescue HTTPStatus::PartialContent, HTTPStatus::NotModified => err
+      res.set_error(err)
+      return true
+    rescue => err
+      return false
+    end
+  end
+
+  def handle_dispatch(req, res, origin = nil) #:nodoc:
+    data = StringIO.new
+    Dispatcher.dispatch(
+      CGI.new("query", create_env_table(req, origin), StringIO.new(req.body || "")), 
+      ActionController::CgiRequest::DEFAULT_SESSION_OPTIONS, 
+      data
+    )
+
+    header, body = extract_header_and_body(data)
+
+    set_charset(header)
+    assign_status(res, header)
+    res.cookies.concat(header.delete('set-cookie') || [])
+    header.each { |key, val| res[key] = val.join(", ") }
+    
+    res.body = body
+    return true
+  rescue => err
+    p err, err.backtrace
+    return false
+  end
+  
+  private
+    def create_env_table(req, origin)
+      env = req.meta_vars.clone
+      env.delete "SCRIPT_NAME"
+      env["QUERY_STRING"] = req.request_uri.query
+      env["REQUEST_URI"]  = origin if origin
+      return env
+    end
+    
+    def extract_header_and_body(data)
+      data.rewind
+      data = data.read
+
+      raw_header, body = *data.split(/^[\xd\xa]{2}/on, 2)
+      header = WEBrick::HTTPUtils::parse_header(raw_header)
+      
+      return header, body
+    end
+    
+    def set_charset(header)
+      ct = header["content-type"]
+      if ct.any? { |x| x =~ /^text\// } && ! ct.any? { |x| x =~ /charset=/ }
+        ch = @server_options[:charset] || "UTF-8"
+        ct.find { |x| x =~ /^text\// } << ("; charset=" + ch)
+      end
+    end
+
+    def assign_status(res, header)
+      if /^(\d+)/ =~ header['status'][0]
+        res.status = $1.to_i
+        header.delete('status')
+      end
+    end
+end

data/src/head/wr_application.c

@@ -73,17 +73,24 @@ void wr_app_wrk_add_timeout_cb(struct ev_loop *loop, ev_timer *w, int revents) {
     app->high_ratio = TOTAL_WORKER_COUNT(app) * WR_MAX_REQ_RATIO;
   }
 
-  //TODO: Check minimum no. of workers and, cretae worker if needed.
+  //TODO: Check minimum no. of workers and, create worker if needed.
   // Also, do not OK if some worker were failed to connect.
   // For timebeing sending OK even if some worker failed to connect.
   if(app->in_use == FALSE && app->ctl && app->pending_wkr == 0) {
     LOG_DEBUG(DEBUG,"Some problem occurred while starting Application %s.", app->conf->name.str);
     scgi_header_add(app->ctl->scgi, "STATUS", strlen("STATUS"), "ERROR", strlen("ERROR"));
-    err_msg_len = sprintf(err_msg,"The application could not be started due to an error. Please refer '/var/log/webroar/%s.log' and the application log file for details.", app->conf->name.str); 
+    err_msg_len = sprintf(err_msg,"The application could not be started due to the following error. Please refer '/var/log/webroar/%s.log' and the application log file for more details.", app->conf->name.str);
     scgi_body_add(app->ctl->scgi, err_msg, err_msg_len);
     wr_ctl_resp_write(app->ctl);
     app->ctl = NULL;
-  } else if(app->in_use == TRUE && TOTAL_WORKER_COUNT(app) < app->conf->min_worker) {
+    if(app->restarted == TRUE){
+      app->old_workers = 0;
+      app->add_workers = 0;
+      app->restarted = FALSE;
+    }
+    //Remove application from the server application list, otherwise it won't allow to add the application with same name, unless stopping it    
+    wr_app_remove(app->svr, app->conf->name.str);
+  } else if(app->in_use == TRUE && (TOTAL_WORKER_COUNT(app) < app->conf->min_worker || app->add_workers)) {
     wr_app_wkr_add(app);
   }
 }
@@ -203,6 +210,65 @@ void wr_app_wrk_remove_cb(struct ev_loop *loop, ev_timer *w, int revents) {
   }
 }
 
+/** Reload the application */
+static inline int wr_app_reload(wr_app_t *app){
+  LOG_FUNCTION
+  wr_wkr_t *worker;
+  wr_app_conf_t *app_conf;
+  short count;
+
+  app->restarted = FALSE;
+  // Remove an old application from the resolver list.
+  wr_req_resolver_remove(app->svr, app);
+
+  // Update the application configuration.
+  app_conf = wr_conf_app_update(app->svr->conf,
+                   app->conf->name.str,
+                   app->svr->err_msg);
+  if(app_conf == NULL){
+    LOG_DEBUG(WARN, "Error: %s",app->svr->err_msg);
+    scgi_body_add(app->ctl->scgi, app->svr->err_msg, strlen(app->svr->err_msg));
+    scgi_header_add(app->ctl->scgi, "STATUS", strlen("STATUS"), "ERROR", strlen("ERROR"));
+    wr_ctl_resp_write(app->ctl);
+    return -1;
+  }
+
+  // Remove old application specification.
+  app->conf->next = NULL;
+  wr_conf_app_free(app->conf);
+  app->conf = app_conf;
+
+  // Add the updated application to resolver list.
+  wr_req_resolver_add(app->svr, app, app_conf);
+
+  // Remove workers based on following logic:
+  // If all the workers are free keep a single worker to process the requests and remove all others.
+  // Else remove all the free workers.
+  count = (app->free_wkr_que->q_count == app->wkr_que->q_count ? 1 :0 );
+
+  LOG_DEBUG(DEBUG,"Free workers queue count is %d. Active worker count is %d.", WR_QUEUE_SIZE(app->free_wkr_que), WR_QUEUE_SIZE(app->wkr_que));
+  LOG_DEBUG(DEBUG,"The %d worker(s) to be removed from free workers list.", WR_QUEUE_SIZE(app->free_wkr_que) - count);
+  while(WR_QUEUE_SIZE(app->free_wkr_que) > count){
+    worker = (wr_wkr_t*)wr_queue_fetch(app->free_wkr_que);
+    // The worker is already removed from free workers list so do not pass the flag.
+    wr_wkr_remove(worker, 0);
+  }
+
+  // Set the number of workers to be removed.
+  app->old_workers = WR_QUEUE_SIZE(app->wkr_que);
+  // Set the number of workers to be added.
+  app->add_workers = app->conf->min_worker;
+  // Mark all existing workers to OLD worker.
+  for(count = 0; count < app->old_workers ; count++) {
+    worker = (wr_wkr_t*)wr_queue_fetch(app->wkr_que);
+    wr_queue_insert(app->wkr_que, worker);
+    worker->state |= WR_WKR_OLD;
+  } 
+
+  LOG_DEBUG(DEBUG,"Number of old and add workers are %d and %d respectively", app->old_workers, app->add_workers);
+  return 0;
+}
+
 /*************** Application function definition *********/
 
 /** Destroy application */
@@ -265,7 +331,7 @@ int wr_app_wkr_add(wr_app_t *app) {
       app->high_ratio = TOTAL_WORKER_COUNT(app) * WR_MAX_REQ_RATIO;
       app->last_wkr_pid[app->pending_wkr-1] = retval;
       ev_timer_again(app->svr->ebb_svr.loop, &app->t_add_timeout);
-      LOG_INFO("PID of created worker = %d, Rails application=%s, ",
+      LOG_INFO("PID of created worker = %d, Rails application=%s",
              app->last_wkr_pid[app->pending_wkr-1],app->conf->path.str);
       return 0;
     }else{
@@ -289,9 +355,10 @@ static int wr_app_insert(wr_svr_t* server, wr_app_conf_t* config, wr_ctl_t *ctl)
   if(strcmp(config->name.str, WR_STATIC_FILE_SERVER_NAME) == 0){
     is_static_server = 1;
   }
-  
-  app->free_wkr_que = wr_queue_new(config->max_worker);
-  app->wkr_que = wr_queue_new(config->max_worker);
+
+  // Queue size is WR_ALLOWED_MAX_WORKERS + 1 to accommodate temporary extra worker, created during application restart 
+  app->free_wkr_que = wr_queue_new(WR_ALLOWED_MAX_WORKERS + 1);
+  app->wkr_que = wr_queue_new(WR_ALLOWED_MAX_WORKERS + 1);
   app->msg_que = wr_queue_new(WR_MSG_QUE_SIZE);
 
   if(  app->wkr_que == NULL ||
@@ -305,6 +372,10 @@ static int wr_app_insert(wr_svr_t* server, wr_app_conf_t* config, wr_ctl_t *ctl)
   app->svr = server;
   app->conf = config;
   app->ctl = ctl;
+  /* set application object in control, it would be used at time of freeing control object */
+  if(ctl) {
+    ctl->app = app;
+  }
   if(!is_static_server){
     wr_req_resolver_add(server, app, config);
     app->next = server->apps;
@@ -326,6 +397,10 @@ static int wr_app_insert(wr_svr_t* server, wr_app_conf_t* config, wr_ctl_t *ctl)
 
   app->pending_wkr = 0;
   app->in_use = FALSE;
+  app->restarted = FALSE;
+  app->old_workers = 0;
+  app->add_workers = 0;
+
   int i;
   for(i = 0; i < WR_MAX_PENDING_WKR ; i ++) {
     app->last_wkr_pid[i] = 0;
@@ -345,6 +420,66 @@ static int wr_app_insert(wr_svr_t* server, wr_app_conf_t* config, wr_ctl_t *ctl)
   return 0;
 }
 
+/** Worker added to application callback */
+void wr_app_wkr_added_cb(wr_app_t *app){
+  LOG_FUNCTION
+  wr_wkr_t *worker;
+
+  // Decrease the add workers count.
+  if(app->add_workers){
+    LOG_DEBUG(DEBUG, "Number of add workers is %d.", app->add_workers);
+    app->add_workers --;
+  }
+
+  // Add a worker if required.
+  if(app->add_workers){
+    LOG_DEBUG(DEBUG,"Add a worker to a reloaded application.");
+    wr_app_wkr_add(app);
+  }else{
+    if(app->old_workers){
+      short count, i;
+      // Remove all the old workers, if there is no more workers to add.
+      LOG_DEBUG(DEBUG, "Number of old workers is %d.", app->old_workers);
+      count = WR_QUEUE_SIZE(app->wkr_que);
+      for( i = 0 ; i < count ; i ++){
+        worker = (wr_wkr_t*) wr_queue_fetch(app->wkr_que);
+        wr_queue_insert(app->wkr_que, worker);
+        if(worker->state & WR_WKR_OLD){
+          // Pass flag to remove worker from the worker free list.
+          wr_wkr_remove(worker, 1);
+          app->old_workers --;
+        }
+      }
+      app->old_workers = 0;
+    }
+
+    // Add worker if total number of worker is less than minimum number of workes.
+    if(TOTAL_WORKER_COUNT(app) < app->conf->min_worker){
+      LOG_DEBUG(DEBUG, "Application does not have minimum number of workes.");
+      wr_app_wkr_add(app);
+    }
+    return;
+  }
+
+  // Remove old worker.
+  if(app->old_workers){
+    short count, i;
+    LOG_DEBUG(DEBUG, "Number of old workers is %d.", app->old_workers);
+    count = WR_QUEUE_SIZE(app->wkr_que);
+    for( i = 0 ; i < count ; i ++){
+      worker = (wr_wkr_t*) wr_queue_fetch(app->wkr_que);
+      wr_queue_insert(app->wkr_que, worker);
+      LOG_DEBUG(DEBUG,"Worker PID is %d and state is %d.", worker->pid, worker->state);
+      if(worker->state & WR_WKR_OLD){
+        // Pass flag to remove worker from the worker free list.
+        wr_wkr_remove(worker, 1);
+        app->old_workers --;
+        break;
+      }
+    }
+  }
+}
+
 /** Add newly created worker to application */
 int wr_app_wrk_insert(wr_svr_t *server, wr_wkr_t *worker,const wr_ctl_msg_t *ctl_msg) {
   LOG_FUNCTION
@@ -358,7 +493,7 @@ int wr_app_wrk_insert(wr_svr_t *server, wr_wkr_t *worker,const wr_ctl_msg_t *ctl
   while(app) {
     LOG_DEBUG(DEBUG,"app->a_config->max_worker = %d, app->wkr_que->q_count =%d", app->conf->max_worker, WR_QUEUE_SIZE(app->wkr_que));
     LOG_DEBUG(DEBUG, "Application name = %s, Application->config->name =%s", app_name, app->conf->name.str );
-    if(app->conf->max_worker > WR_QUEUE_SIZE(app->wkr_que)
+    if((app->conf->max_worker > WR_QUEUE_SIZE(app->wkr_que) || app->restarted == TRUE || app->add_workers > 0)
         && strcmp(app_name, app->conf->name.str) == 0) {
       int i;
       for(i = 0; i < app->pending_wkr ; i++) {
@@ -396,6 +531,11 @@ int wr_app_wrk_insert(wr_svr_t *server, wr_wkr_t *worker,const wr_ctl_msg_t *ctl
           app->ctl = NULL;
         }
       }
+
+      if(app->restarted == TRUE){
+        return wr_app_reload(app);
+      }
+
       return 0;
     }
     app = app->next;
@@ -495,7 +635,9 @@ void wr_app_add_cb(wr_ctl_t *ctl, const wr_ctl_msg_t *ctl_msg) {
   }
   ctl->svr->err_msg[0] = 0;
   if(app) {
-    sprintf(ctl->svr->err_msg, "Appliation '%s' is already running.", ctl_msg->msg.app.app_name.str);
+    /* set application object in control, it would be used at time of freeing control object */
+    ctl->app = app;
+    sprintf(ctl->svr->err_msg, "Application '%s' is already running.", ctl_msg->msg.app.app_name.str);
   }
   
   if(!app && ctl && ctl->svr && ctl->svr->conf) {
@@ -506,7 +648,7 @@ void wr_app_add_cb(wr_ctl_t *ctl, const wr_ctl_msg_t *ctl_msg) {
       if(wr_app_insert(ctl->svr, app_conf, ctl) >= 0)
         return;
     } else if(ctl->svr->err_msg[0] == 0) {
-      sprintf(ctl->svr->err_msg, "Appliation '%s' is not found.", ctl_msg->msg.app.app_name.str);
+      sprintf(ctl->svr->err_msg, "Application '%s' is not found.", ctl_msg->msg.app.app_name.str);
     }
   }
 
@@ -530,23 +672,72 @@ void wr_app_remove_cb(wr_ctl_t *ctl, const wr_ctl_msg_t *ctl_msg) {
 /** Allication reload callback */
 void wr_app_reload_cb(wr_ctl_t *ctl, const wr_ctl_msg_t *ctl_msg) {
   LOG_FUNCTION
-  if(wr_app_remove(ctl->svr, ctl_msg->msg.app.app_name.str) < 0) {
-    scgi_body_add(ctl->scgi,
-                          "Couldn't remove application. But trying to start appliaction.",
-                          strlen("Couldn't remove application. But trying to start appliaction."));
+  wr_app_t *app = ctl->svr->apps;
+  wr_app_conf_t* app_config = NULL;
+
+  // Find the application.
+  while(app) {
+    if(strcmp(ctl_msg->msg.app.app_name.str, app->conf->name.str)==0){
+      /* set application object in control, it would be used at time of freeing control object */
+      ctl->app = app;
+      break;
+    }
+    app = app->next;
   }
 
-  wr_app_conf_t* app = NULL;
-  app = wr_conf_app_read(ctl->svr->conf,
+  // Read new application configuration.
+  app_config = wr_conf_app_update(ctl->svr->conf,
                          ctl_msg->msg.app.app_name.str,
                          ctl->svr->err_msg);
-  if(app!=NULL) {
-    if(wr_app_insert(ctl->svr, app, ctl) >= 0)
-      return;
-  } else {
-    LOG_DEBUG(WARN, "Error: %s",ctl->svr->err_msg);
+  // Report error on not getting the application configuration.
+  if(app_config == NULL){
+    LOG_ERROR(WARN, "Error: %s",ctl->svr->err_msg);
     scgi_body_add(ctl->scgi, ctl->svr->err_msg, strlen(ctl->svr->err_msg));
+    scgi_header_add(ctl->scgi, "STATUS", strlen("STATUS"), "ERROR", strlen("ERROR"));
+    wr_ctl_resp_write(ctl);
+    // Add old application configuration to server configuration.
+    if(app){
+      LOG_DEBUG(WARN,"Replace the application configuration with old one.");
+      wr_conf_app_replace(app->svr->conf, app->conf);
+    }
+    return;
   }
+
+  if(app) {
+    int i;
+    wr_app_conf_t *tmp_app_conf = app->conf;
+    // Set variables to restart the application.
+    LOG_DEBUG(DEBUG,"Set variables to restart an existing application.");
+    app->conf = app_config;
+    app->in_use = FALSE;
+    app->restarted = TRUE;
+    app->pending_wkr = 0;
+    for(i = 0; i < WR_MAX_PENDING_WKR ; i ++) {
+      app->last_wkr_pid[i] = 0;
+    }
+    app->ctl = ctl;
+    LOG_DEBUG(4,"%s() Application Added:%s", __FUNCTION__, app->conf->name.str);
+
+    // Add single worker with updated application.
+    LOG_DEBUG(DEBUG, "Add first worker on application restart.");
+    wr_app_wkr_add(app);
+
+    // Replace the application configuration with older configuration object.
+    wr_conf_app_replace(app->svr->conf, tmp_app_conf);
+    app->conf = tmp_app_conf;
+    return;
+  }else{
+    // If application didn't found, report an error and create new application.
+    LOG_ERROR(WARN,"Aapplication %s didn't found in list", ctl_msg->msg.app.app_name.str);
+    sprintf(ctl->svr->err_msg, "Application '%s' is not found.", ctl_msg->msg.app.app_name.str);
+    scgi_body_add(ctl->scgi,
+                          "Couldn't remove application. But trying to start application.",
+                          strlen("Couldn't remove application. But trying to start application."));
+    if(wr_app_insert(ctl->svr, app_config, ctl) == 0)
+      return;
+  }
+
+  // Return ERROR status.
   scgi_header_add(ctl->scgi, "STATUS", strlen("STATUS"), "ERROR", strlen("ERROR"));
   wr_ctl_resp_write(ctl);
 }