ruote-kit 2.1.10 → 2.1.11

data/lib/ruote-kit/views/process.html.haml

@@ -1,55 +1,122 @@
+
+- # under the MIT license, see LICENSE.txt
+
 - @_uses_fluo = true
 
-%h2
+%h1
+  process
   = @process.wfid
-  (#{@process.definition_name})
-
-.options
-  %ul.nolist
-    /
-      %li.b5
-        %form{ :method => 'post' }
-          %input{ :type => 'hidden', :name => '_method', :value => 'put' }
-          = button "Pause", 'force-block'
-          %span.description PUT /_ruote/processes/#{@process.wfid}?_pause=1
-    %li.b5
+
+%canvas#fluo
+
+%table.details
+  %tr
+    %td
+      name
+    %td
+      &= @process.definition_name
+      &= @process.definition_revision
+  %tr
+    %td
+      position
+    %td
+      - @process.position.each do |pos|
+        - text = "#{pos[1]} #{pos[2]['task']}"
+        - expid = pos.first.split('!').first
+        %span{ :onmouseover => "Fluo.highlight('fluo', '#{expid}');", :onmouseout => "Fluo.highlight('fluo');" }
+          - if @process.stored_workitems.find { |wi| wi.fei.sid == pos.first }
+            = alink(:workitems, pos.first, :text => text)
+          - else
+            = text
+  %tr
+    %td
+      expressions
+    %td
+      = alink(:expressions, @process.wfid, :text => @process.expressions.size)
+  %tr
+    %td
+      workitems
+    %td
+      #{@process.workitems.size} out,
+      - text = "#{@process.stored_workitems.size} in storage participant"
+      - if @process.stored_workitems.size > 0
+        = alink(:workitems, @process.wfid, :text => text)
+      - else
+        = text
+  %tr
+    %td
+      errors
+    %td
+      - if @process.errors.size > 0
+        = alink(:errors, @process.wfid, :text => @process.errors.size)
+      - else
+        0
+  %tr
+    %td
+      launch time
+    %td
+      = Time.parse(@process.launched_time).localtime.strftime('%Y/%m/%d %H:%M:%S')
+  %tr
+    %td
+      last active
+    %td
+      = Time.parse(@process.last_active).localtime.strftime('%Y/%m/%d %H:%M:%S')
+  %tr
+    %td
+      tags
+    %td
+      &= @process.tags.collect { |ta| ta.first }.join(', ')
+  
+  %tr
+    %td.no_border{ :colspan => 2 }
+       
+
+  %tr
+    %td
+      cancel expression
+    %td
       %form{ :method => 'post' }
         %input{ :type => 'hidden', :name => '_method', :value => 'delete' }
-        = button "Cancel", "cancel force-block"
+        %input{ :type => 'submit', :value => 'cancel', :onclick => 'return confirm("really ?");' }
         %span.description DELETE /_ruote/processes/#{@process.wfid}
-    %li.b5
+  %tr
+    %td
+      kill expression
+    %td
       %form{ :method => 'post' }
         %input{ :type => 'hidden', :name => '_method', :value => 'delete' }
         %input{ :type => 'hidden', :name => '_kill', :value => '1' }
-        = button "Kill", "cancel force-block"
+        %input{ :type => 'submit', :value => 'kill', :onclick => 'return confirm("really ?");' }
         %span.description DELETE /_ruote/processes/#{@process.wfid}?_kill=1
-
-%ul.nolist
-  %li wfid: #{@process.wfid}
-  %li launch: #{@process.launched_time}
-  /%li paused:
-  %li: tags: #{@process.all_tags.keys.join(', ')}
-  %li
-    expressions:
-    %a{ :href => "/_ruote/expressions/#{@process.wfid}" } GET /_ruote/expressions/#{@process.wfid}
-  %li
-    workitems:
-    %a{ :href => "/_ruote/workitems/#{@process.wfid}" } GET /_ruote/workitems/#{@process.wfid}
-  %li errors: #{@process.errors.size}
-
-%ul
-  %li TODO
-  %li Branches
-  %li Process variables
-  %li Scheduled jobs
-  %li Active expression
-  %li Tree
-
-%p  
-
-%canvas#fluo
+  %tr
+    %td
+      expressions
+    %td
+      GET
+      = alink(:expressions, @process.wfid)
+  %tr
+    %td
+      workitems
+    %td
+      GET
+      = alink(:workitems, @process.wfid)
+  %tr
+    %td
+      errors
+    %td
+      GET
+      = alink(:errors, @process.wfid)
+  %tr
+    %td
+      schedules
+    %td
+      GET
+      = alink(:schedules, @process.wfid)
 
 :javascript
-  var proc_rep = #{process_tree( @process )};
-  Fluo.renderFlow( 'fluo', proc_rep );
+
+  var proc_rep = #{process_tree(@process)};
+  Fluo.renderFlow('fluo', proc_rep);
   Fluo.crop('fluo');
+  Fluo.resizeForMaxWidth('fluo', $('body').width() / 2.1);
+

data/lib/ruote-kit/views/process_launched.html.haml

@@ -1,6 +1,10 @@
-%h2 Process launched
+
+- # under the MIT license, see LICENSE.txt
+
+%h1 process launched
 
 .flash
   .message
     .notice
-      %p Your process has been launched. #{ link_to "GET /_ruote/processes/#{@wfid}", "/_ruote/processes/#{@wfid}" }
+      %p process #{alink(:processes, @wfid)} has been launched.
+

data/lib/ruote-kit/views/processes.html.haml

@@ -1,27 +1,58 @@
-%h2 Processes
 
-.flash
-  .message
-    - if @processes.empty?
-      .warn
-        %p No processes are currently running
-    - else
-      .notice
-        %p Currently running #{@processes.size} processes
+- # under the MIT license, see LICENSE.txt
+
+%h1 processes
+
+= haml :_pagination, :layout => false
+
+%table.list
+  %thead
+    %td
+      wfid
+    %td
+      name
+    %td
+      position
+    %td
+      tags
+    %td
+      launched
+    %td
+      last active
+    %td
+      exps
+    %td
+      errs
+    %td
+      wis
 
-%ul.nested_list
   - @processes.each do |process|
-    %li
-      = link_to process
-      %ul.nested_details
-        %li wfid: #{process.wfid}
-        %li process: #{process.definition_name} (#{process.definition_revision})
-        %li launched: #{process.launched_time}
-        %li tags: #{process.all_tags.keys.join(', ')}
-        %li
-          expressions:
-          %a{ :href => "/_ruote/expressions/#{process.wfid}" } GET /_ruote/expressions/#{process.wfid}
-        %li
-          workitems:
-          %a{ :href => "/_ruote/workitems/#{process.wfid}" } GET /_ruote/workitems/#{process.wfid}
-        %li errors: #{process.errors.size}
+    %tr
+      %td
+        = alink(:processes, process.wfid, :text => process.wfid)
+      %td
+        &= process.definition_name
+        &= process.definition_revision
+      %td
+        - process.position.each do |pos|
+          - stored_wi = process.stored_workitems.find { |wi| wi.fei.sid == pos[0] }
+          - text = "#{pos[1]} #{pos[2]['task']}"
+          - if stored_wi
+            = alink(:workitems, stored_wi.fei.sid, :text => text)
+          - else
+            &= text
+      %td
+        &= process.tags.collect { |ta| ta.first }.join(', ')
+      %td
+        = Time.parse(process.launched_time).localtime.strftime('%Y/%m/%d %H:%M:%S')
+      %td
+        = Time.parse(process.last_active).localtime.strftime('%Y/%m/%d %H:%M:%S')
+      %td.right{ :title => 'expressions' }
+        = alink(:expressions, process.wfid, :text => process.expressions.size)
+      %td.right{ :title => 'errors' }
+        - if process.errors.size > 0
+          = alink(:errors, process.wfid, :text => process.errors.size)
+      %td.right{ :title => 'workitems' }
+        - if process.stored_workitems.size > 0
+          = alink(:workitems, process.wfid, :text => process.stored_workitems.size)
+

data/lib/ruote-kit/views/processes_new.html.haml

@@ -0,0 +1,36 @@
+
+- # under the MIT license, see LICENSE.txt
+
+- @_uses_fluo = true
+
+
+%h1 launch process
+
+%form{ :method => 'POST', :action => '/_ruote/processes', :enctype => 'multipart/form-data', :accept_charset => 'UTF-8' }
+
+  %input{ :type => 'hidden', :name => '_snowman', :value => '☃' }
+
+  %div
+    %label
+      process definition
+      %a.ruote_button.ruote_go_button{ :title => 'open process definition editor', :href => '', :onclick => 'showEditor(); return false;' }
+
+    %textarea#tree{ :name => 'definition', :cols => 80, :rows => 10 } #{sample_process}
+
+  %div
+    %label
+      workitem fields
+    %textarea{ :name => 'fields', :cols => 80, :rows => 3 }
+
+  %div
+    %label.togglable{ :onclick => 'Rk.toggle(this, $("textarea.variables")[0], "(process variables)", "process variables");' }
+      (process variables)
+    %textarea.variables{ :name => 'variables', :cols => 80, :rows => 3 }
+
+  %div
+    %input{ :type => 'submit', 'value' => 'launch' }
+    or
+    %a{ :href => '/_ruote/processes' } cancel
+
+= haml :_tree_editor, :layout => false
+

data/lib/ruote-kit/views/schedules.html.haml

@@ -0,0 +1,42 @@
+
+- # under the MIT license, see LICENSE.txt
+
+%h1 schedules
+
+= haml :_pagination, :layout => false
+
+%table.list
+ 
+  %thead
+    %td
+      owner / [ target ]
+    %td
+      process schedules
+    %td
+      type
+    %td
+      put at
+    %td
+      original
+    %td
+      at
+
+  - @schedules.each do |schedule|
+    %tr
+      %td
+        %div
+          = alink(:expressions, schedule['owner'].sid)
+        - if schedule['owner'] != schedule['target']
+          %div
+            = alink(:expressions, schedule['target'].sid)
+      %td
+        = alink(:schedules, schedule['owner'].wfid)
+      %td
+        &= schedule['type']
+      %td
+        = Time.parse(schedule['put_at']).localtime.strftime('%Y/%m/%d %H:%M:%S')
+      %td
+        &= schedule['original']
+      %td
+        = Time.parse(schedule['at']).localtime.strftime('%Y/%m/%d %H:%M:%S')
+

data/lib/ruote-kit/views/workitem.html.haml

@@ -1,39 +1,93 @@
+
+- # under the MIT license, see LICENSE.txt
+
 - @_uses_fluo = true
 
-%h2 Workitem #{@workitem.fei.wfid}/#{@workitem.fei.expid}
+%h1
+  workitem
+  = @workitem.fei.sid
 
-%ul.nolist
-  %li fei: #{@workitem.fei.to_s}
-  %li participant: #{@workitem.participant_name}
-  %li dispatched: #{@workitem.dispatch_at}
-  %li last modified: #{@workitem.h.put_at}
-  %li process: #{link_to engine.process( @workitem.fei.wfid) }
-  %li expressions:
-  %li workitems of this process: #{link_to "GET /_ruote/workitems/#{@workitem.fei.wfid}", "/_ruote/workitems/#{@workitem.fei.wfid}" }
+%canvas#fluo
 
-%p  
+%form{ :method => 'POST', :enctype => 'multipart/form-data', :accept_charset => 'UTF-8' }
 
-%form.form{ :method => 'post' }
   %input{ :type => 'hidden', :name => '_method', :value => 'put' }
-  %input{ :type => 'hidden', :name => '_procced', :value => '1' }
-  .group
-    %label.label{ :for => "fields" } Fields
-    %textarea.text_area{ :name => "fields", :cols => 80, :rows => 10 }
-      = Rufus::Json.encode(@workitem.fields)
-    %span.description The current workitem fields in JSON format
-  .group
-    %input{ :type => 'checkbox', :name => '_proceed', :value => '1' }
-    %label{ :for => '_proceed' } Proceed the workflow (_proceed=1)
-    %br
-    %span.description Check to let the workflow proceed, leave unchecked to just update workitem fields
-  .group.navform
-    %input.submit{ :type => 'submit', :value => "PUT /_ruote/workitems/#{@workitem.fei.wfid}/#{@workitem.fei.expid}" }
-
-%p  
+  %input{ :type => 'hidden', :name => '_snowman', :value => '☃' }
 
-%canvas#fluo
+  %table.details
+    %tr
+      %td
+        participant
+      %td
+        &= @workitem.participant_name
+    %tr
+      %td
+        dispatched at
+      %td
+        - if @workitem.dispatched_at
+          = Time.parse(@workitem.dispatched_at).localtime.strftime('%Y/%m/%d %H:%M:%S')
+    %tr
+      %td
+        last modified
+      %td
+        = Time.parse(@workitem.h.put_at).localtime.strftime('%Y/%m/%d %H:%M:%S')
+
+    %tr
+      %td.no_border{ :colspan => 2 }
+         
+
+    %tr
+      %td
+        process
+      %td
+        GET
+        = alink(:processes, @workitem.fei.wfid)
+    %tr
+      %td
+        expression
+      %td
+        GET
+        = alink(:expressions, @workitem.fei.sid)
+    %tr
+      %td
+        other workitems
+      %td
+        GET
+        = alink(:workitems, @workitem.fei.wfid)
+
+    %tr
+      %td.no_border{ :colspan => 2 }
+         
+
+    %tr
+      %td
+        params
+      %td
+        - fields = @workitem.fields.dup
+        - params = fields.delete('params') || {}
+        - params.delete('ref')
+        - fields.delete('dispatched_at')
+        &= Rufus::Json.encode(params)[1..-2]
+    %tr
+      %td
+        fields
+      %td.no_padding
+        %textarea{ :name => "fields", :cols => 80, :rows => 10 } #{Rufus::Json.pretty_encode(@workitem.fields)}
+    %tr
+      %td
+        proceed ?
+      %td
+        %input{ :type => 'checkbox', :name => '_proceed' }
+    %tr
+      %td
+      %td
+        %input{ :type => 'submit', :value => "PUT /_ruote/workitems/#{@workitem.fei.sid}" }
 
 :javascript
-  var proc_rep = #{process_tree( @workitem )};
-  Fluo.renderFlow( 'fluo', proc_rep, { 'workitems' : ['#{@workitem.fei.expid}'] } );
+
+  var proc_rep = #{process_tree(@workitem)};
+
+  Fluo.renderFlow('fluo', proc_rep, { 'workitems' : ['#{@workitem.fei.expid}'] });
   Fluo.crop('fluo');
+  Fluo.resizeForMaxWidth('fluo', $('body').width() / 2.1);
+

data/lib/ruote-kit/views/workitems.html.haml

@@ -1,23 +1,46 @@
-%h2 Workitems
 
-.flash
-  .message
-    - if @workitems.empty?
-      .warn
-        %p No workitems are currently available #{ @wfid ? "for #{@wfid}" : '' }
-    - else
-      .notice
-        %p #{ pluralize(@workitems.size, 'workitem') } available #{ @wfid ? "for #{@wfid}" : '' }
+- # under the MIT license, see LICENSE.txt
 
-    - if @participants
-      .notice
-        %p Filtered for participant(s): #{@participants.join(', ')}
+%h1
+  workitems
+  = @wfid ? "for #{@wfid}" : ''
+
+= haml :_pagination, :layout => false
+
+%table.list
+
+  %thead
+    %td
+      id
+    %td
+      process
+    %td
+      participant
+    %td
+      params
+    %td
+      dispatched at
+    %td
+      fields
 
-%ul.nested_list
   - @workitems.each do |wi|
-    %li
-      = link_to wi
-      %ul.nested_details
-        %li fei: #{wi.fei.to_s}
-        %li participant: #{wi.participant_name}
-        %li dispath time: TODO
+    %tr
+      %td
+        = alink(:workitems, wi.fei.sid, :text => wi.fei.sid)
+      %td
+        = alink(:processes, wi.wfid, :text => wi.wfid)
+      %td
+        &= wi.participant_name
+      %td
+        - params = (wi.fields['params'] || {}).dup
+        - params.delete('ref')
+        &= Rufus::Json.encode(params)[1..-2]
+      %td
+        - if wi.dispatched_at
+          = Time.parse(wi.dispatched_at).localtime.strftime('%Y/%m/%d %H:%M:%S')
+      %td
+        - fields = wi.fields.dup
+        - fields.delete('params')
+        - fields.delete('dispatched_at')
+        = Rufus::Json.encode(fields)[1..-2][0, 28]
+

data/lib/ruote-kit.rb

@@ -1,109 +1,38 @@
+
+# license is MIT, see LICENSE.txt
+
+require 'ostruct'
+
 require 'rufus-json'
 require 'ruote'
 require 'ruote/part/storage_participant'
 require 'ruote-kit/version'
 
+
 module RuoteKit
 
-  autoload :Configuration, "ruote-kit/configuration"
-  autoload :Application,   "ruote-kit/application"
-  autoload :Helpers,       "ruote-kit/helpers"
+  autoload :Application, 'ruote-kit/application'
 
   class << self
-    # The instance of ruote
-    attr_accessor :engine
 
-    # The instance of our worker, if used
-    attr_accessor :worker
+    attr_accessor :engine
 
     def env
-      @env ||= (
-        if defined?( Rails )
-          Rails.env
-        else
-          ENV['RACK_ENV'] || 'development'
-        end
-      )
-    end
-
-    # Yields a RuoteKit::Configuration instance and then immediately starts
-    # the engine.
-    def configure
-      yield configuration if block_given?
-
-      run_engine!
-    end
-    alias run! configure
-
-    def shutdown!( purge_engine = false )
-      shutdown_engine( purge_engine )
-    end
-
-    def configuration
-      @configuration ||= Configuration.new
-    end
-
-    # Ensure the engine is running
-    def ensure_engine!
-      run_engine! if self.engine.nil?
-    end
-
-    # Runs an engine, and starts a threaded workers if #configuration allows
-    # it
-    def run_engine!
-
-      return unless configuration.run_engine
-
-      storage = configuration.storage_instance
-
-      self.engine = Ruote::Engine.new( configuration.run_worker ? self.worker = Ruote::Worker.new(storage) : storage )
-
-      configuration.do_participant_registration
-
-      @storage_participant = nil
-    end
-
-    # Run a single worker. By default this method will block indefinitely,
-    # unless +run_in_thread+ is set to true
-    def run_worker!( run_in_thread = false )
-      self.worker = Ruote::Worker.new( configuration.storage_instance )
-      run_in_thread ? self.worker.run_in_thread : self.worker.run
-    end
-
-    def shutdown_engine( purge = false )
-
-      return if self.engine.nil?
-
-      self.engine.shutdown
-
-      if purge
-        self.engine.context.keys.each do |k|
-          s = self.engine.context[k]
-          s.purge if s.respond_to?(:purge)
-        end
-      end
-
-      self.engine = nil
-
-      shutdown_worker! if configuration.run_worker
-    end
-
-    def shutdown_worker!
-      self.worker.shutdown if self.worker
-      self.worker = nil
+      @env ||= defined?(Rails) ? Rails.env : ENV['RACK_ENV'] || 'development'
     end
 
     def storage_participant
-      return nil if self.engine.nil?
-      @storage_participant ||= Ruote::StorageParticipant.new(self.engine)
+      engine.storage_participant
     end
 
-    # resets the configuration
-    #
-    # mainly used in tests
-    def reset_configuration!
-      @configuration = nil
+    def run_worker (storage)
+      RuoteKit.engine = Ruote::Engine.new(
+        Ruote::Worker.new(storage), :join => true)
     end
 
+    def bind_engine (storage)
+      RuoteKit.engine = Ruote::Engine.new(storage)
+    end
   end
 end
+