resque-status 0.1.0

data/lib/resque/server/views/status.erb

@@ -0,0 +1,57 @@
+<%= status_view :status_styles, :layout => false %>
+
+<h1 class='wi'>Statuses: <%= @status.uuid %>/<%= @status.name %></h1>
+<p class='intro'>Viewing a specific job created with JobWithStatus. <a href="/statuses">Return to the list of statuses</a></p>
+
+<div class="status-holder" rel="<%= @status.status %>" id="status_<%= @status.uuid %>">
+  <div class="status-progress">
+    <div class="status-progress-bar status-<%= @status.status %>" style="width: <%= @status.pct_complete %>%;"></div>
+    <p><%= @status.pct_complete %>%</p>
+  </div>
+  <div class="status-message"><%= @status.message %></div>
+  <div class="status-time"><%= @status.time? ? @status.time : 'Not started' %></div>
+</div>
+
+<script type="text/javascript" charset="utf-8">
+  jQuery(function($) {
+
+    // itterate over the holders
+    $('.status-holder').each(function() {
+      checkStatus($(this));
+    });
+
+    function checkStatus($status) {
+      var status_id = $status.attr('id').replace('status_', '');
+      $.getJSON('/statuses/' + status_id + '.js', function(json) {
+        if (json) {
+          var pct = "0%";
+          if (json.pct_complete) {
+            var pct = json.pct_complete + "%";
+          }
+          $status.find('.status-progress-bar').animate({width: pct});
+          $status.find('.status-progress p').text(pct)        
+          if (json.message) {
+            $status.find('.status-message').html(json.message)
+          }
+          if (json.status) {
+            $status
+              .attr('rel', json.status)
+              .find('.status-progress-bar')
+                .attr('class', '')
+                .addClass('status-progress-bar status-' + json.status);
+          }
+          if (json.time) {
+            $status.find('.status-time').text(new Date(json.time * 1000).toString())
+          }
+        };
+        var status = $status.attr('rel');
+        if (status == 'working' || status == 'queued' || status == "") {
+          setTimeout(function() {
+            checkStatus($status)
+          }, 1500);
+        }
+      });
+    };
+
+  });
+</script>

data/lib/resque/server/views/status_styles.erb

@@ -0,0 +1,98 @@
+<style type="text/css" media="screen">
+  th.progress {
+    width: 100px;
+  }
+  td.progress {
+    position: relative;
+    width: 100px;
+    display:block;
+  }
+  td.status {
+    font-weight: bold;
+  }
+  td.progress .progress-bar {
+    position: absolute;
+    top: 0px;
+    left: 0px;
+    background: #999;
+    display:block;
+    height: 100%;
+    z-index: 0;
+    opacity: 0.5;
+    -moz-opacity: 0.5;
+    -webkit-opacity: 0.5;
+  }
+  td.progress .progress-pct {
+    z-index: 10;
+    color: #333;
+  }
+  
+  .status-holder {
+    background: #F7F7F7;
+    border: 1px solid #E5E5E5;
+    padding: 20px;
+    font-size: 110%;
+    margin-bottom: 40px;
+  }
+  .status-progress {
+    width: 100%;
+    height: 30px;
+    border: 1px solid #CCC;
+    background: #E5E5E5;
+    position:relative;
+    margin: 5px 0px;
+  }
+  .status-progress-bar {
+    position:absolute;
+    top: 0px;
+    left: 0px;
+    height: 30px;
+    background: #CCC;
+  }
+  .status-progress p {
+    position:absolute;
+    top: 5px;
+    left: 10px;
+    z-index: 15;
+    display:block;
+    color: #FFF;
+    padding: 0px;
+    font-weight: bold;
+  }
+  .status-message {
+    font-weight: bold;
+  }
+  .status-time {
+    font-size: 70%;
+    padding: 10px 0px;
+    color: #999;
+  }
+  .status-progress-bar.status-completed {
+    background:#61BF55;
+  }
+  .status-progress-bar.status-failed {
+   background: #E47E74;
+  }
+  .status-progress-bar.status-working {
+    background: #528499;
+  }
+  .status-progress-bar.status-killed {
+    background: #B84F16;
+  }
+  .status-completed {
+    color:#61BF55;
+  }
+  .status-failed {
+    color: #E47E74;
+  }
+  .status-working {
+    color: #528499;
+  }
+  .status-killed {
+    color: #B84F16;
+  }
+  #main a.kill:link, #main a.kill:visited {
+    color: #B84F16;
+    font-weight: bold;
+  }
+</style>

data/lib/resque/server/views/statuses.erb

@@ -0,0 +1,60 @@
+<%= status_view :status_styles, :layout => false %>
+
+<h1 class='wi'>Statuses</h1>
+<p class='intro'>These are recent jobs created with the JobWithStatus class</p>
+<table>
+  <tr>
+    <th>ID</th>
+    <th>Name</th>
+    <th>Status</th>
+    <th>Last Updated</th>
+    <th class="progress">% Complete</th>
+    <th>Message</th>
+    <th>Kill</th>
+  </tr>
+  <% unless @statuses.empty? %>
+    <% @statuses.each do |status| %>
+    <tr>
+      <td><a href="/statuses/<%= status.uuid %>"><%= status.uuid %></a></td>
+      <td><%= status.name %></td>
+      <td class="status status-<%= status.status %>"><%= status.status %></td>
+      <td class="time"><%= status.time %></td>
+      <td class="progress">
+        <div class="progress-bar" style="width:<%= status.pct_complete %>%">&nbsp;</div>
+        <div class="progress-pct"><%= status.pct_complete ? "#{status.pct_complete}%" : '' %></div>
+      </td>
+      <td><%= status.message %></td>
+      <td><% if status.killable? %><a href="/statuses/<%= status.uuid %>/kill" class="kill">Kill</a><% end %></td>
+    </tr>
+    <% end %>
+  <% else %>  
+  <tr>
+    <td colspan="7" class='no-data'>No Statuses right now...</td>
+  </tr>
+  <% end %>
+</table>
+
+<script type="text/javascript" charset="utf-8">
+  jQuery(function($) {
+    
+    $('a.kill').click(function(e) {
+      e.preventDefault();
+      var $link = $(this),
+          url = $link.attr('href'),
+          confirmed = confirm("Are you sure you want to kill this job? There is no undo.");
+      if (confirmed) {
+        $link.animate({opacity: 0.5});
+        $.ajax({
+          url: url,
+          type: 'post',
+          success: function() {
+            $link.remove();
+          }
+        });
+      } else {
+        return false
+      }
+    });
+    
+  });
+</script>

data/lib/resque/status.rb

@@ -0,0 +1,206 @@
+require 'resque'
+require 'redisk'
+require 'uuid'
+
+module Resque
+  # Resque::Status is a Hash object that has helper methods for dealing with 
+  # the common status attributes. It also has a number of class methods for 
+  # creating/updating/retrieving status objects from Redis
+  class Status < Hash
+    VERSION = '0.1.0'
+
+    extend Resque::Helpers
+
+    # Create a status, generating a new UUID, passing the message to the status
+    # Returns the UUID of the new status.
+    def self.create(message = nil)
+      uuid = generate_uuid
+      set(uuid, message)
+      redis.zadd(set_key, Time.now.to_i, uuid)
+      redis.zremrangebyscore(set_key, 0, Time.now.to_i - @expire_in) if @expire_in
+      uuid
+    end
+
+    # Get a status by UUID. Returns a Resque::Status
+    def self.get(uuid)
+      val = redis.get(status_key(uuid))
+      val ? Resque::Status.new(uuid, decode(val)) : nil
+    end
+
+    # set a status by UUID. <tt>messages</tt> can be any number of stirngs or hashes
+    # that are merged in order to create a single status.
+    def self.set(uuid, *messages)
+      val = Resque::Status.new(uuid, *messages)
+      redis.set(status_key(uuid), encode(val))
+      if expire_in
+        redis.expire(status_key(uuid), expire_in) 
+      end
+      val
+    end
+    
+    # returns a Redisk::Logger scoped to the UUID. Any options passed are passed
+    # to the logger initialization.
+    def self.logger(uuid, options = {})
+      Redisk::Logger.new(logger_key(uuid), options)
+    end
+
+    # Return <tt>num</tt> Resque::Status objects in reverse chronological order.
+    # By default returns the entire set.
+    def self.statuses(num = -1)
+      status_ids(num).collect do |id|
+        get(id)
+      end.compact
+    end
+    
+    # Return the <tt>num</tt> most recent status/job UUIDs in reverse chronological order.
+    def self.status_ids(num = -1)
+      redis.zrevrange set_key, 0, num
+    end
+                                                                                          
+    # Kill the job at UUID on its next iteration this works by adding the UUID to a
+    # kill list (a.k.a. a list of jobs to be killed. Each iteration the job checks 
+    # if it _should_ be killed by calling <tt>tick</tt> or <tt>at</tt>. If so, it raises
+    # a <tt>Resque::JobWithStatus::Killed</tt> error and sets the status to 'killed'.
+    def self.kill(uuid)                 
+      redis.sadd(kill_key, uuid)
+    end
+    
+    # Remove the job at UUID from the kill list
+    def self.killed(uuid)
+      redis.srem(kill_key, uuid)
+    end
+    
+    # Return the UUIDs of the jobs on the kill list
+    def self.kill_ids
+      redis.smembers(kill_key)
+    end
+    
+    # Check whether a job with UUID is on the kill list
+    def self.should_kill?(uuid)
+      redis.sismember(kill_key, uuid)
+    end
+    
+    # The time in seconds that jobs and statuses should expire from Redis (after
+    # the last time they are touched/updated)
+    def self.expire_in
+      @expire_in
+    end
+    
+    # Set the <tt>expire_in</tt> time in seconds
+    def self.expire_in=(seconds)
+      @expire_in = seconds.nil? ? nil : seconds.to_i
+    end
+    
+    def self.status_key(uuid)
+      "status:#{uuid}"
+    end
+
+    def self.set_key
+      "_statuses"
+    end
+
+    def self.kill_key
+      "_kill"
+    end 
+
+    def self.logger_key(uuid)
+      "_log:#{uuid}"
+    end
+
+    def self.generate_uuid
+      UUID.generate(:compact)
+    end
+
+    def self.hash_accessor(name, options = {})
+      options[:default] ||= nil 
+      coerce = options[:coerce] ? ".#{options[:coerce]}" : ""
+      module_eval <<-EOT
+      def #{name}
+        value = (self['#{name}'] ? self['#{name}']#{coerce} : #{options[:default].inspect})
+        yield value if block_given?
+        value
+      end
+
+      def #{name}=(value)
+        self['#{name}'] = value
+      end
+
+      def #{name}?
+        !!self['#{name}']
+      end
+      EOT
+    end
+
+    STATUSES = %w{queued working completed failed killed}.freeze
+
+    hash_accessor :uuid
+    hash_accessor :name
+    hash_accessor :status
+    hash_accessor :message
+    hash_accessor :time
+
+    hash_accessor :num
+    hash_accessor :total
+    
+    # Create a new Resque::Status object. If multiple arguments are passed
+    # it is assumed the first argument is the UUID and the rest are status objects.
+    # All arguments are subsequentily merged in order. Strings are assumed to 
+    # be messages.
+    def initialize(*args)
+      super nil
+      base_status = {
+        'time' => Time.now.to_i,
+        'status' => 'queued'
+      }
+      base_status['uuid'] = args.shift if args.length > 1
+      status_hash = args.inject(base_status) do |final, m|
+        m = {'message' => m} if m.is_a?(String)
+        final.merge(m || {})
+      end
+      self.replace(status_hash)
+    end
+    
+    # calculate the % completion of the job based on <tt>status</tt>, <tt>num</tt>
+    # and <tt>total</tt>
+    def pct_complete
+      case status
+      when 'completed' then 100
+      when 'queued' then 0
+      when 'failed' then 100
+      else
+        t = (total == 0 || total.nil?) ? 1 : total
+        (((num || 0).to_f / t.to_f) * 100).to_i
+      end
+    end
+    
+    # Return the time of the status initialization. If set returns a <tt>Time</tt>
+    # object, otherwise returns nil
+    def time
+      time? ? Time.at(self['time']) : nil
+    end
+
+    STATUSES.each do |status|
+      define_method("#{status}?") do
+        self['status'] === status 
+      end
+    end
+    
+    # Can the job be killed? 'failed', 'completed', and 'killed' jobs cant be killed
+    # (for pretty obvious reasons)
+    def killable?
+      !['failed', 'completed', 'killed'].include?(self.status)
+    end
+    
+    # Return a JSON representation of the current object.
+    def to_json
+      h = self.dup
+      h['pct_complete'] = pct_complete
+      self.class.encode(h)
+    end
+
+    def inspect
+      "#<Resque::Status #{super}>"
+    end
+
+  end
+end

data/lib/resque/status_server.rb

@@ -0,0 +1,44 @@
+require 'resque/status'
+
+module Resque
+  module StatusServer
+    
+    VIEW_PATH = File.join(File.dirname(__FILE__), 'server', 'views')
+    
+    def self.registered(app)
+      
+      app.get '/statuses' do
+        @statuses = Resque::Status.statuses
+        status_view(:statuses)
+      end
+      
+      app.get '/statuses/:id.js' do
+        @status = Resque::Status.get(params[:id])
+        content_type :js
+        @status.to_json
+      end
+      
+      app.get '/statuses/:id' do
+        @status = Resque::Status.get(params[:id])
+        status_view(:status)
+      end
+      
+      app.post '/statuses/:id/kill' do
+        Resque::Status.kill(params[:id])
+        redirect '/statuses'
+      end
+      
+      app.helpers do
+        def status_view(filename, options = {}, locals = {})
+          erb(File.read(File.join(VIEW_PATH, "#{filename}.erb")), options, locals)
+        end
+      end
+      
+      app.tabs << "Statuses"
+      
+    end
+
+  end
+end
+
+Resque::Server.register Resque::StatusServer