inst-jobs 0.11.0

data/lib/delayed/server/helpers.rb

@@ -0,0 +1,28 @@
+module Delayed
+  class Server
+    module Helpers
+      def h(text)
+        Rack::Utils.escape_html(text)
+      end
+
+      def url_path(*path_parts)
+        [path_prefix, path_parts].join('/').squeeze('/')
+      end
+
+      def path_prefix
+        request.env['SCRIPT_NAME']
+      end
+
+      def render_javascript_env
+        {
+          Routes: {
+            root: path_prefix,
+            running: url_path('running'),
+            tags: url_path('tags'),
+            jobs: url_path('jobs'),
+          }
+        }.to_json
+      end
+    end
+  end
+end

data/lib/delayed/server/public/css/app.css

@@ -0,0 +1,12 @@
+table.dataTable td {
+    word-wrap: break-word;
+}
+table.dataTable td.strand {
+    max-width: 100px;
+}
+table.dataTable td.tag {
+    max-width: 100px;
+}
+div.job-list-row {
+    padding-top: 10px;
+}

data/lib/delayed/server/public/js/app.js

@@ -0,0 +1,132 @@
+(function () {
+    var Delayed = {};
+
+    Delayed.Render = {};
+    Delayed.Render.attempts = function (previousAttempts, callType, jobData) {
+        var thisAttempt = parseInt(previousAttempts, 10) + 1;
+        switch(callType) {
+            case "display":
+                return thisAttempt + "/" + jobData.max_attempts;
+            default:
+                return thisAttempt;
+        }
+    };
+
+    Delayed.Render.runTime = function (lockedAt, callType) {
+        var elapsed, days, hours, minutes, seconds, remaining, formattedTime;
+        elapsed = Math.round((new Date().getTime() - Date.parse(lockedAt)) / 1000);
+        switch(callType) {
+            case "display": {
+                days = Math.floor(elapsed / 86400);
+                remaining = elapsed - (days * 86400);
+                hours = Math.floor(remaining / 3600);
+                remaining = remaining - (hours * 3600);
+                minutes = Math.floor(remaining / 60);
+                seconds = remaining - (minutes * 60);
+                formattedTime = ""
+                if(days > 0) {
+                    formattedTime = days + "d "
+                }
+                formattedTime = formattedTime + ("0" + hours).slice(-2) + ":" + ("0" + minutes).slice(-2) + ":" + ("0" + seconds).slice(-2);
+                return formattedTime;
+            }
+            default:
+                return elapsed;
+        }
+    };
+
+    $(document).ready(function () {
+        var runningTable, runningInterval, tagsTable, tagsInterval, jobsTable, jobsInterval
+        runningTable = $('#running').DataTable({
+            "autoWidth": false,
+            "bSort": false,
+            "paging": false,
+            "processing": true,
+            "searching": false,
+            "scrollY": "200px",
+            "serverSide": true,
+            "order": [[5, "desc"]],
+            "ajax": ENV.Routes.running,
+            "columns": [
+                {"data": "id"},
+                {"data": "locked_by", "className": "worker"},
+                {"data": "tag", "className": "tag"},
+                {"data": "attempts", "render": Delayed.Render.attempts, "className": "attempts"},
+                {"data": "strand", "className": "strand"},
+                {"data": "locked_at", "render": Delayed.Render.runTime}
+            ]
+        });
+        runningInterval = setInterval(function () { runningTable.ajax.reload(); }, 2000);
+
+        tagsTable = $("#tags").DataTable({
+            "autoWidth": false,
+            "bSort": false,
+            "paging": false,
+            "processing": true,
+            "searching": false,
+            "scrollY": "200px",
+            "order": [[1, "desc"]],
+            "ajax": ENV.Routes.tags,
+            "columns": [
+                {"data": "tag", "className": "tag"},
+                {"data": "count"}
+            ]
+        });
+        tagsInterval = setInterval(function () { tagsTable.ajax.reload(); }, 10000);
+
+        jobsTable = $("#jobs").DataTable({
+            "autoWidth": false,
+            "bSort": false,
+            "paging": true,
+            "processing": true,
+            "searching": false,
+            "scrollY": "200px",
+            "serverSide": true,
+            "order": [[1, "desc"]],
+            "ajax": {
+                "url": ENV.Routes.jobs,
+                "data": function (data) {
+                    data.flavor      = $("select#current_jobs_flavor").val();
+                    data.search_term = $("input#jobs_search_term").val();
+                }
+            },
+            "columns": [
+                {"data": "id"},
+                {"data": "tag", "className": "tag"},
+                {"data": "attempts", "render": Delayed.Render.attempts},
+                {"data": "priority"},
+                {"data": "strand"},
+                {"data": "run_at"}
+            ]
+        });
+
+        $('body').on('click', '.refresh_jobs_link', function(event) {
+            event.preventDefault();
+            jobsTable.ajax.reload();
+            return true
+        });
+
+        $('body').on('change', 'select#current_jobs_flavor', function (event) {
+            event.preventDefault();
+            $selectBox = $(this);
+            $selectedOption = $($selectBox.children(':selected'));
+            $searchDiv = $('div#job_search');
+
+            if ($selectedOption.data('requires-search')) {
+                $searchDiv.show();
+            } else {
+                $searchDiv.hide();
+            }
+
+            jobsTable.ajax.reload();
+            return true
+        });
+
+        $('body').on('keyup', '#jobs_search_term', function (event) {
+            if (event.keyCode == 13) {
+                jobsTable.ajax.reload();
+            }
+            return true
+        });
+    });
+})();

data/lib/delayed/server/views/index.erb

@@ -0,0 +1,90 @@
+<div class="row">
+  <div class="col-md-8">
+    <h2>Running</h2>
+    <table id="running" class="table table-striped table-bordered">
+      <thead>
+        <tr>
+          <th>ID</th>
+          <th>Worker</th>
+          <th>Tag</th>
+          <th>Attempt</th>
+          <th>Strand</th>
+          <th>Runtime</th>
+        </tr>
+      </thead>
+      <tbody>
+      </tbody>
+    </table>
+  </div>
+  <div class="col-md-4">
+    <h2>Tags</h2>
+    <table id="tags" class="table table-striped table-bordered">
+      <thead>
+        <tr>
+          <th>Tag</th>
+          <th>Count</th>
+        </tr>
+      </thead>
+      <tbody>
+      </tbody>
+    </table>
+  </div>
+</div>
+
+<div class="row">
+  <div class="col-md-12">
+    <h2>Jobs List</h2>
+  </div>
+</div>
+
+<div class="row">
+  <div class="form-group">
+    <div class="col-md-2">
+      <select id="current_jobs_flavor" class="form-control">
+        <option value="current">Current</option>
+        <option value="future">Future</option>
+        <option value="failed">Failed</option>
+        <option value="id" data-requires-search="true">ID</option>
+        <option value="strand" data-requires-search="true">Strand</option>
+        <option value="tag" data-requires-search="true">Tag</option>
+      </select>
+    </div>
+    <div class="col-md-3">
+      <!-- this inline style makes me sad but doing it in the stylesheet seems to break bootstrap -->
+      <div class="input-group" id="job_search" style="display: none;">
+        <input type="text" class="form-control" id="jobs_search_term" placeholder="">
+        <span class="input-group-btn">
+          <a href="" class="btn btn-default refresh_jobs_link" aria-label="Run Search">
+            Filter <span class="glyphicon glyphicon-filter"></span>
+          </a>
+        </span>
+      </div>
+    </div>
+    <div class="col-md-6">
+    </div>
+    <div class="col-md-1">
+      <a href="" class="btn btn-default pull-right refresh_jobs_link" aria-label="Refresh Jobs Table">
+        <span class="glyphicon glyphicon-refresh"></span> Refresh
+      </a>
+    </div>
+  </div>
+</div>
+
+<div class="row job-list-row">
+  <div class="col-md-12">
+    <table id="jobs" class="table table-striped table-bordered">
+      <thead>
+        <tr>
+          <th>ID</th>
+          <th>Tag</th>
+          <th>Attempt</th>
+          <th>Priority</th>
+          <th>Strand</th>
+          <th>Run At</th>
+        </tr>
+      </thead>
+      <tbody>
+      </tbody>
+    </table>
+  </div>
+</div>

data/lib/delayed/server/views/layout.erb

@@ -0,0 +1,47 @@
+<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8">
+<meta http-equiv="X-UA-Compatible" content="IE=edge">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<script type="text/javascript" charset="utf8">
+window.ENV = <%= render_javascript_env %>
+</script>
+<script type="text/javascript" charset="utf8 "src="//code.jquery.com/jquery-2.1.3.min.js" defer></script>
+<script type="text/javascript" charset="utf8" src="//maxcdn.bootstrapcdn.com/bootstrap/3.3.4/js/bootstrap.min.js" defer></script>
+<script type="text/javascript" charset="utf8" src="//cdn.datatables.net/1.10.6/js/jquery.dataTables.js" defer></script>
+<script type="text/javascript" charset="utf8" src="//cdn.datatables.net/plug-ins/1.10.6/integration/bootstrap/3/dataTables.bootstrap.js" defer></script>
+<script type="text/javascript" charset="utf8" src="<%= url_path 'js/app.js' %>" defer></script>
+
+<link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.4/css/bootstrap.min.css">
+<link rel="stylesheet" href="//cdn.datatables.net/plug-ins/1.10.6/integration/bootstrap/3/dataTables.bootstrap.css">
+<link rel="stylesheet" href="<%= url_path 'css/app.css' %>">
+
+<title>Delayed Jobs</title>
+</head>
+<body>
+  <nav class="navbar navbar-default">
+    <div class="container-fluid">
+      <!-- Brand and toggle get grouped for better mobile display -->
+      <div class="navbar-header">
+        <button type="button" class="navbar-toggle collapsed" data-toggle="collapse" data-target="#bs-example-navbar-collapse-1" aria-expanded="false">
+          <span class="sr-only">Toggle navigation</span>
+          <span class="icon-bar"></span>
+          <span class="icon-bar"></span>
+          <span class="icon-bar"></span>
+        </button>
+        <a class="navbar-brand" href="<%= url_path '/' %>">Delayed Jobs</a>
+      </div>
+
+      <!-- Collect the nav links, forms, and other content for toggling -->
+      <div class="collapse navbar-collapse" id="bs-example-navbar-collapse-1">
+        <ul class="nav navbar-nav">
+        </ul>
+      </div><!-- /.navbar-collapse -->
+    </div><!-- /.container-fluid -->
+  </nav>
+  <div class="container">
+  <%= yield %>
+  </div>
+</body>
+</html>

data/lib/delayed/server.rb

@@ -0,0 +1,120 @@
+require 'sinatra/base'
+require 'sinatra/json'
+require 'json'
+require 'delayed_job'
+
+module Delayed
+  class Server < Sinatra::Base
+    APP_DIR = File.dirname(File.expand_path(__FILE__))
+    set :views,         File.join(APP_DIR, 'server', 'views')
+    set :public_folder, File.join(APP_DIR, 'server', 'public')
+
+    def initialize(*args, &block)
+      super()
+      # Rails will take care of establishing the DB connection for us if there is
+      # an application present
+      if using_active_record? && !ActiveRecord::Base.connected?
+        ActiveRecord::Base.establish_connection(ENV['DATABASE_URL'])
+      end
+    end
+
+    def using_active_record?
+      Delayed::Job == Delayed::Backend::ActiveRecord::Job
+    end
+
+    # Ensure we're connected to the DB before processing the request
+    before do
+      if ActiveRecord::Base.respond_to?(:verify_active_connections!) && using_active_record?
+        ActiveRecord::Base.verify_active_connections!
+      end
+    end
+
+    # Release any used connections back to the pool
+    after do
+      ActiveRecord::Base.clear_active_connections! if using_active_record?
+    end
+
+    configure :development do
+      require 'sinatra/reloader'
+      register Sinatra::Reloader
+    end
+
+    helpers do
+      # this can't get required until the class has been opened for the first time
+      require 'delayed/server/helpers'
+      include Delayed::Server::Helpers
+    end
+
+    get '/' do
+      erb :index
+    end
+
+    get '/running' do
+      content_type :json
+      json({
+        draw: params['draw'].to_i,
+        recordsTotal: Delayed::Job.running.count,
+        recordsFiltered: Delayed::Job.running.count,
+        data: Delayed::Job.running_jobs.map{ |j|
+          j.as_json(include_root: false, except: [:handler, :last_error])
+        },
+      })
+    end
+
+    get '/tags' do
+      content_type :json
+      json({
+        draw: params['draw'].to_i,
+        data: Delayed::Job.tag_counts('current', 10)
+      })
+    end
+
+    DEFAULT_PAGE_SIZE = 10
+    MAX_PAGE_SIZE = 100
+    get '/jobs' do
+      content_type :json
+      flavor = params['flavor'] || 'current'
+      page_size = extract_page_size
+      offset = Integer(params['start'] || 0)
+      case flavor
+      when 'id'
+        jobs = Delayed::Job.where(id: params['search_term'])
+        total_records = 1
+      when 'future', 'current', 'failed'
+        jobs = Delayed::Job.list_jobs(flavor, page_size, offset)
+        total_records =  Delayed::Job.jobs_count(flavor)
+      else
+        query = params['search_term']
+        if query.present?
+          jobs = Delayed::Job.list_jobs(flavor, page_size, offset, query)
+        else
+          jobs = []
+        end
+        total_records =  Delayed::Job.jobs_count(flavor, query)
+      end
+      json({
+        draw: params['draw'].to_i,
+        recordsTotal: total_records,
+        recordsFiltered: jobs.size,
+        data: build_jobs_json(jobs),
+      })
+    end
+
+    private
+
+    def extract_page_size
+      page_size = Integer(params['length'] || DEFAULT_PAGE_SIZE)
+      # if dataTables wants all of the records it will send us -1 but we don't
+      # want the potential to kill our servers with this request so we'll limit it
+      page_size = DEFAULT_PAGE_SIZE if page_size == -1
+      [page_size, MAX_PAGE_SIZE].min
+    end
+
+
+    def build_jobs_json(jobs)
+      json = jobs.map{ |j|
+        j.as_json(root: false, except: [:handler, :last_error])
+      }
+    end
+  end
+end

data/lib/delayed/settings.rb

@@ -0,0 +1,90 @@
+require 'yaml'
+require 'erb'
+
+module Delayed
+  module Settings
+    SETTINGS = [
+      :queue,
+      :max_attempts,
+      :sleep_delay,
+      :sleep_delay_stagger,
+      :fetch_batch_size,
+      :select_random_from_batch,
+      :worker_procname_prefix,
+      :pool_procname_suffix,
+      :default_job_options,
+      :silence_periodic_log,
+      :disable_periodic_jobs,
+      :disable_automatic_orphan_unlocking,
+      :last_ditch_logfile,
+      :parent_process_client_timeout,
+    ]
+    SETTINGS_WITH_ARGS = [ :num_strands ]
+
+    SETTINGS.each do |setting|
+      mattr_writer(setting)
+      self.send("#{setting}=", nil)
+      define_singleton_method(setting) do
+        val = class_variable_get(:"@@#{setting}")
+        val.respond_to?(:call) ? val.call() : val
+      end
+    end
+
+    mattr_accessor(*SETTINGS_WITH_ARGS)
+
+    def self.queue=(queue_name)
+      raise(ArgumentError, "queue_name must not be blank") if queue_name.blank?
+      @@queue = queue_name
+    end
+
+    self.queue = "queue"
+    self.max_attempts = 1
+    self.sleep_delay = 2.0
+    self.sleep_delay_stagger = 2.0
+    self.fetch_batch_size = 5
+    self.select_random_from_batch = false
+    self.silence_periodic_log = false
+    self.parent_process_client_timeout = 10.0
+
+    self.num_strands = ->(strand_name){ nil }
+    self.default_job_options = ->{ Hash.new }
+
+    def self.worker_config(config_filename = nil)
+      config_filename ||= default_worker_config_name
+      config = YAML.load(ERB.new(File.read(config_filename)).result)
+      env = defined?(RAILS_ENV) ? RAILS_ENV : ENV['RAILS_ENV'] || 'development'
+      config = config[env] || config['default']
+      # Backwards compatibility from when the config was just an array of queues
+      config = { :workers => config } if config.is_a?(Array)
+      unless config && config.is_a?(Hash)
+        raise ArgumentError,
+          "Invalid config file #{config_filename}"
+      end
+      config = config.with_indifferent_access
+      config[:workers].map! do |worker_config|
+        config.except(:workers).merge(worker_config.with_indifferent_access)
+      end
+      config
+    end
+
+    def self.apply_worker_config!(config)
+      SETTINGS.each do |setting|
+        self.send("#{setting}=", config[setting.to_s]) if config.key?(setting.to_s)
+      end
+    end
+
+    def self.default_worker_config_name
+      expand_rails_path("config/delayed_jobs.yml")
+    end
+
+    # Expands rails-relative paths, without depending on rails being loaded.
+    def self.expand_rails_path(path)
+      root = if defined?(Rails) && Rails.root
+        (Rails.root+"Gemfile").to_s
+      else
+        ENV.fetch('BUNDLE_GEMFILE')
+      end
+      File.expand_path("../#{path}", root)
+    end
+  end
+end

data/lib/delayed/testing.rb

@@ -0,0 +1,32 @@
+module Delayed
+module Testing
+  def self.run_job(job)
+    Delayed::Worker.new.perform(job)
+  end
+
+  def self.drain
+    while job = Delayed::Job.get_and_lock_next_available(
+        'spec run_jobs',
+        Delayed::Settings.queue,
+        0,
+        Delayed::MAX_PRIORITY)
+      run_job(job)
+    end
+  end
+
+  def self.track_created
+    job_tracking = JobTracking.track { yield }
+    job_tracking.created
+  end
+
+  def self.clear_all!
+    case Delayed::Job.name
+    when /Redis/
+      Delayed::Job.redis.flushdb
+    when /ActiveRecord/
+      Delayed::Job.delete_all
+      Delayed::Job::Failed.delete_all
+    end
+  end
+end
+end

data/lib/delayed/version.rb

@@ -0,0 +1,3 @@
+module Delayed
+  VERSION = "0.11.0"
+end

data/lib/delayed/work_queue/in_process.rb

@@ -0,0 +1,13 @@
+module Delayed
+module WorkQueue
+# The simplest possible implementation of a WorkQueue -- just turns around and
+# queries the queue inline.
+class InProcess
+  def get_and_lock_next_available(worker_name, queue_name, min_priority, max_priority)
+    Delayed::Worker.lifecycle.run_callbacks(:work_queue_pop, self) do
+      Delayed::Job.get_and_lock_next_available(worker_name, queue_name, min_priority, max_priority)
+    end
+  end
+end
+end
+end