oflow 0.5.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c60c057bc56ccdf1457715ab9e7c73af54614bb2
-  data.tar.gz: b20b4b16b01f875c7848bb9f442ca3e67213cda7
+  metadata.gz: d36c10496898f7cb6df17b4be3ba103cb8098169
+  data.tar.gz: 563283b71b4e11bd6b207a464b9204722d472f02
 SHA512:
-  metadata.gz: a22ef32835f66cb4cccc81330a76d82c25a03ce3c646a878ea9ebe4b89fc4b2011747e540a53fe1e87c7e530e34407af8309139e5a87bbec1cd124edc3157930
-  data.tar.gz: d9e903de2ecafa7b7cb386182bcc194905f7d571801dccde61ebbab82e4236f4b28626854d61d8f2556164d8e710536d120e5a1ec103a0edf10d9752af2d52bb
+  metadata.gz: 0d0572af84b50544594563dd86e625c1b86b444702d793ea1585cc870b31f07194903677e1a65a9c6b0d798b7e7a44031c233ca8e3764f36273c20fdb13ce9ff
+  data.tar.gz: 6ca630368b0c25ee789e761043bbca9dcfb8e11fadf590ef8b19017b0d5ea1811c36135d9c9f2e0ab41b97e8f8776a7d969a88678c5c5a223eea4e2adf203c3c

data/README.md

@@ -25,6 +25,10 @@ Follow [@peterohler on Twitter](http://twitter.com/#!/peterohler) for announceme
 
 ## Release Notes
 
+### Release 0.6
+
+ - Added HTTP Server Actor that acts as a simple HTTP server.
+
 ### Release 0.5
 
  - Added Persister Actor that acts as a simple local store database.
@@ -119,13 +123,13 @@ Hello World!
 
 ## Future Features
 
- - Balancer Actor that distributes to a set of others Tasks based on how busy each is.
+ - HTTP Server Actor
 
- - Merger Actor that waits for a criteria to be met before continuing.
+ - OmniGraffle file input for configuration.
 
- - HTTP Server Actor
+ - .svg file input for configuration.
 
- - Persister Actor that writes to disk and reads on start)
+ - Visio file input for configuration.
 
  - CallOut Actor that uses pipes and fork to use a non-Ruby actor.
 
@@ -133,12 +137,6 @@ Hello World!
 
  - Dynamic links to Tasks and Flows.
 
- - OmniGraffle file input for configuration.
-
- - .svg file input for configuration.
-
- - Visio file input for configuration.
-
  - High performance C version. Proof of concept puts the performance range at
    around 10M operations per second where an operation is one task execution per
    thread.

data/lib/oflow/actors.rb

@@ -10,6 +10,8 @@ require 'oflow/actors/log'
 require 'oflow/actors/errorhandler'
 
 require 'oflow/actors/balancer'
+require 'oflow/actors/trigger'
 require 'oflow/actors/merger'
 require 'oflow/actors/persister'
 require 'oflow/actors/timer'
+require 'oflow/actors/httpserver'

data/lib/oflow/actors/httpserver.rb

@@ -0,0 +1,238 @@
+
+require 'socket'
+require 'time'
+require 'fcntl'
+
+module OFlow
+  module Actors
+
+    # Provides a simple HTTP server that accepts requests which then trigger a
+    # flow. The execution flow should end back at the server so it can sent a
+    # response to the requester.
+    class HttpServer < Trigger
+
+      def initialize(task, options)
+        super
+        @sessions = { }
+        
+        @server = TCPServer.new(@port)
+        @server.fcntl(Fcntl::F_SETFL, @server.fcntl(Fcntl::F_GETFL, 0) | Fcntl::O_NONBLOCK)
+        @server_loop = Thread.start(self) do |me|
+          Thread.current[:name] = me.task.full_name() + '-server'
+          while Task::CLOSING != task.state
+            begin
+              if Task::BLOCKED == task.state || Task::STOPPED == task.state
+                sleep(0.1)
+                next
+              end
+              session = @server.accept_nonblock()
+              session.fcntl(Fcntl::F_SETFL, session.fcntl(Fcntl::F_GETFL, 0) | Fcntl::O_NONBLOCK)
+              @count += 1
+              req = read_req(session, @count)
+              @sessions[@count] = session
+              resp = {
+                status: 200,
+                body: nil,
+                headers: {
+                  'Content-Type' => 'text/html',
+                }
+              }
+              box = new_event()
+              box.contents[:request] = req
+              box.contents[:response] = resp
+              task.links.each_key do |key|
+                continue if :success == key || 'success' == key
+                begin
+                  task.ship(key, box)
+                rescue BlockedError => e
+                  task.warn("Failed to ship timer #{box.contents} to #{key}. Task blocked.")
+                rescue BusyError => e
+                  task.warn("Failed to ship timer #{box.contents} to #{key}. Task busy.")
+                end
+              end
+            rescue IO::WaitReadable, Errno::EINTR
+              IO.select([@server], nil, nil, 0.5)
+            rescue Exception => e
+              task.handle_error(e)
+            end
+          end
+        end
+      end
+
+      def perform(op, box)
+        case op
+        when :reply
+          req_id = box.get(@req_id_path)
+          if (session = @sessions[req_id]).nil?
+            raise NotFoundError.new(task.full_name, 'session', req_id)
+          end
+          if (resp = box.get(@response_path)).nil?
+            raise NotFoundError.new(task.full_name, 'response', @response_path)
+          end
+          body = resp[:body]
+          body = '' if body.nil?
+          status = resp[:status]
+          headers = ["HTTP/1.1 #{status} {STATUS_MESSAGES[status]}"]
+          resp[:headers].each do |k,v|
+            headers << "#{k}: #{v}"
+          end
+          headers << "Content-Length: #{body.length}\r\n\r\n"
+          session.puts headers.join("\r\n")
+          session.puts body
+          session.close
+          @sessions.delete(req_id)
+        when :skip
+          req_id = box.get(@req_id_path)
+          if (session = @sessions[req_id]).nil?
+            raise NotFoundError.new(task.full_name, 'session', req_id)
+          end
+          @sessions.delete(req_id)
+        else
+          raise OpError.new(task.full_name, op)
+        end
+        task.ship(:success, Box.new(nil, box.tracker)) unless task.links[:success].nil?
+      end
+
+      def set_options(options)
+        super
+        @port = options.fetch(:port, 6060)
+        @req_id_path = options.fetch(:req_id_path, 'request:id')
+        @response_path = options.fetch(:response_path, 'response')
+        @read_timeout = options.fetch(:read_timeout, 1.0)
+      end
+
+      def read_req(session, id)
+        req = {
+          id: id,
+        }
+        line = session.gets()
+        parts = line.split(' ')
+        req[:method] = parts[0]
+        req[:protocol] = parts[2]
+        path, arg_str = parts[1].split('?', 2)
+        req[:path] = path
+        args = nil
+        unless arg_str.nil?
+          args = arg_str.split('&').map { |pair| pair.split('=') }
+        end
+        req[:args] = args
+
+        # Read the rest of the lines and the body if there is one.
+        len = 0
+        while line = session.gets()
+          line.strip!
+          break if 0 == line.size
+          parts = line.split(':', 2)
+          next unless 2 == parts.size
+          key = parts[0]
+          value = parts[1].strip()
+          if 'Content-Length' == key
+            value = value.to_i
+            len = value
+          end
+          req[key] = value
+        end
+        req[:body] = read_timeout(session, len, @read_timeout) if 0 < len
+        req
+      end
+
+      def read_timeout(session, len, timeout)
+        str = ''
+        done = Time.now() + timeout
+        loop do
+          begin
+            str = session.readpartial(len, str)
+            break if str.size == len
+          rescue  Errno::EAGAIN => e
+            raise e if IO.select([session], nil, nil, done - Time.now()).nil?
+            retry
+          end
+        end
+        str
+      end
+
+      STATUS_MESSAGES = {
+        100 => 'Continue',
+        101 => 'Switching Protocols',
+        102 => 'Processing',
+        200 => 'OK',
+        201 => 'Created',
+        202 => 'Accepted',
+        203 => 'Non-Authoritative Information',
+        204 => 'No Content',
+        205 => 'Reset Content',
+        206 => 'Partial Content',
+        207 => 'Multi-Status',
+        208 => 'Already Reported',
+        226 => 'IM Used',
+        300 => 'Multiple Choices',
+        301 => 'Moved Permanently',
+        302 => 'Found',
+        303 => 'See Other',
+        304 => 'Not Modified',
+        305 => 'Use Proxy',
+        306 => 'Switch Proxy',
+        307 => 'Temporary Redirect',
+        308 => 'Permanent Redirect',
+        400 => 'Bad Request',
+        401 => 'Unauthorized',
+        402 => 'Payment Required',
+        403 => 'Forbidden',
+        404 => 'Not Found',
+        405 => 'Method Not Allowed',
+        406 => 'Not Acceptable',
+        407 => 'Proxy Authentication Required',
+        408 => 'Request Timeout',
+        409 => 'Conflict',
+        410 => 'Gone',
+        411 => 'Length Required',
+        412 => 'Precondition Failed',
+        413 => 'Request Entity Too Large',
+        414 => 'Request-URI Too Long',
+        415 => 'Unsupported Media Type',
+        416 => 'Requested Range Not Satisfiable',
+        417 => 'Expectation Failed',
+        418 => "I'm a teapot",
+        419 => 'Authentication Timeout',
+        420 => 'Method Failure',
+        422 => 'Unprocessed Entity',
+        423 => 'Locked',
+        424 => 'Failed Dependency',
+        425 => 'Unordered Collection',
+        426 => 'Upgrade Required',
+        428 => 'Precondition Required',
+        429 => 'Too Many Requests',
+        431 => 'Request Header Fields Too Long',
+        440 => 'Login Timeout',
+        444 => 'No Response',
+        449 => 'Retry With',
+        450 => 'Blocked by Windows Parental Controls',
+        451 => 'Unavailable For Legal Reasons',
+        494 => 'Request Header Too Large',
+        495 => 'Cert Error',
+        496 => 'No Cert',
+        497 => 'HTTP tp HTTP',
+        499 => 'Client Closed Request',
+        500 => 'Internal Server Error',
+        501 => 'Not Implemented',
+        502 => 'Bad Gateway',
+        503 => 'Service Unavailable',
+        504 => 'Gateway Timeout',
+        505 => 'HTTP Version Not Supported',
+        506 => 'Variant Also Negotiates',
+        507 => 'Insufficient Storage',
+        508 => 'Loop Detected',
+        509 => 'Bandwidth Limit Exceeded',
+        510 => 'Not Extended',
+        511 => 'Network Authentication Required',
+        520 => 'Original Error',
+        522 => 'Connection timed out',
+        523 => 'Proxy Declined Request',
+        524 => 'A timeout occurred',
+        598 => 'Network read timeout error',
+        599 => 'Network connect timeout error',
+      }
+
+    end # HttpServer
+  end # Actors
+end # OFlow

data/lib/oflow/actors/log.rb

@@ -14,6 +14,11 @@ module OFlow
         :warn => Logger::Severity::WARN,
         :info => Logger::Severity::INFO,
         :debug => Logger::Severity::DEBUG,
+        :FATAL => Logger::Severity::FATAL,
+        :ERROR => Logger::Severity::ERROR,
+        :WARN => Logger::Severity::WARN,
+        :INFO => Logger::Severity::INFO,
+        :DEBUG => Logger::Severity::DEBUG,
       }
       def initialize(task, options={})
         @logger = nil

data/lib/oflow/actors/trigger.rb

@@ -0,0 +1,46 @@
+
+module OFlow
+  module Actors
+
+    class Trigger < Actor
+      
+      # Label for the Tracker is used and for trigger content.
+      attr_reader :label
+      # Boolean flag indicating a tracker should be added to the trigger content
+      # if true.
+      attr_reader :with_tracker
+      # The number of time the timer has fired or shipped.
+      attr_reader :count
+
+      def initialize(task, options)
+        super
+        @count = 0
+        set_options(options)
+      end
+      
+      def new_event()
+        tracker = @with_tracker ? Tracker.create(@label) : nil
+        Box.new({ source: task.full_name, label: @label, timestamp: Time.now.utc() }, tracker)
+      end
+
+      def set_options(options)
+        set_with_tracker(options[:with_tracker])
+        @label = options[:label].to_s
+      end
+
+      def set_label(v)
+        v = v.to_s unless v.nil?
+        @label = v
+      end
+
+      def set_with_tracker(v)
+        v = false if v.nil?
+        unless true == v || false == v
+          raise ConfigError.new("Expected with_tracker to be a boolean, not a #{v.class}.")
+        end
+        @with_tracker = v
+      end
+
+    end # Trigger
+  end # Actors
+end # OFlow

data/lib/oflow/box.rb

@@ -74,7 +74,11 @@ module OFlow
 
     # Returns a string representation of the Box and contents.
     def to_s()
-      "Box{#{@contents}, tracker: #{@tracker}}"
+      if @tracker.nil?
+        "Box{#{@contents}}"
+      else
+        "Box{#{@contents}, tracker: #{@tracker}}"
+      end
     end
     alias inspect to_s
 
@@ -152,14 +156,14 @@ module OFlow
           value[ps] = _aset(path[1..-1], value[ps], rv)
         end
       when NilClass
-        begin
-          i = p.to_i
-          value = []
-          value[i] = _aset(path[1..-1], nil, rv)
-        rescue
+        if /^\d+$/.match(p).nil?
           ps = p.to_sym
           value = {}
           value[ps] = _aset(path[1..-1], nil, rv)
+        else
+          i = p.to_i
+          value = []
+          value[i] = _aset(path[1..-1], nil, rv)
         end
       else
         raise FrozenError.new(p, value)

data/lib/oflow/errors.rb

@@ -44,6 +44,13 @@ module OFlow
     end
   end # LinkError
 
+  # An Exception indicating an item was not found.
+  class NotFoundError < Exception
+    def initialize(name, type, id)
+      super("The #{type} identified as '#{id}' was not found in #{name}.")
+    end
+  end # NotFoundError
+
   # An Exception raised when there are validation errors.
   class ValidateError < Exception
     attr_accessor :problems

data/lib/oflow/haslinks.rb

@@ -59,6 +59,10 @@ module OFlow
     def links()
       @links
     end
-    
+
+    def has_links?()
+      !@links.nil? && !@links.empty?
+    end
+
   end # HasLinks
 end # OFlow

data/lib/oflow/haslog.rb

@@ -30,7 +30,14 @@ module OFlow
     # @param msg [String] message to log
     # @param fn [String] full name of Task or Flow calling the log function
     def log_msg(level, msg, fn)
+      # Abort early if the log severity/level would not log the message. This
+      # also allows non-Loggers to be used in place of the Log Actor.
+      return if Env.log_level > Actors::Log::SEVERITY_MAP[level]
+
       lt = log()
+      # To prevent infinite looping, don't allow the logger to log to itself.
+      return if self == lt
+
       unless lt.nil?
         lt.receive(level, Box.new([msg, fn]))
       else

data/lib/oflow/task.rb

@@ -52,6 +52,7 @@ module OFlow
       init_links()
       set_options(options)
 
+      info("Creating actor #{actor_class} with options #{options}.")
       @actor = actor_class.new(self, options)
       raise Exception.new("#{actor} does not respond to the perform() method.") unless @actor.respond_to?(:perform)
 
@@ -76,6 +77,7 @@ module OFlow
 
               @current_req = req
               begin
+                info("perform(#{req.op}, #{req.box})")
                 @actor.perform(req.op, req.box) unless req.nil?
               rescue Exception => e
                 handle_error(e)
@@ -279,6 +281,8 @@ module OFlow
     # @param op [Symbol] operation to perform
     # @param box [Box] contents or data for the request
     def receive(op, box)
+      info("receive(#{op}, #{box}) #{state_string}")
+
       return if CLOSING == @state
 
       raise BlockedError.new() if BLOCKED == @state
@@ -313,6 +317,7 @@ module OFlow
       box.freeze() unless box.nil?
       link = resolve_link(dest)
       raise LinkError.new(dest) if link.nil? || link.target.nil?
+      info("shipping #{box} to #{link.target_name}:#{link.op}")
       link.target.receive(link.op, box)
       link
     end

data/lib/oflow/version.rb

@@ -1,5 +1,5 @@
 
 module OFlow
   # Current version of the module. 
-  VERSION = '0.5.0'
+  VERSION = '0.6.0'
 end

data/test/actors/httpserver_test.rb

@@ -0,0 +1,57 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+[ File.dirname(__FILE__),
+  File.join(File.dirname(__FILE__), "../../lib"),
+  File.join(File.dirname(__FILE__), "..")
+].each { |path| $: << path unless $:.include?(path) }
+
+require 'net/http'
+require 'test/unit'
+require 'oflow'
+require 'oflow/test'
+
+class Reply < ::OFlow::Actor
+  
+  def initialize(task, options)
+    super
+  end
+
+  def perform(op, box)
+    reply = box.get('request')
+    box = box.set('response:body', reply.to_s)
+    task.ship(nil, box)
+  end
+
+end # Reply
+
+class HttpServerTest < ::Test::Unit::TestCase
+
+  def test_httpserver
+    ::OFlow::Env.flow('http-server', port: 6060) { |f|
+      f.task('server', ::OFlow::Actors::HttpServer) { |t|
+        t.link(nil, :reply, nil)
+      }
+      f.task(:reply, Reply) { |t|
+        t.link(nil, :server, :reply)
+      }
+    }
+    # GET
+    uri = URI('http://localhost:6060/test?a=1&b=two')
+    reply = Net::HTTP.get(uri)
+    assert_equal(%|{:id=>1, :method=>"GET", :protocol=>"HTTP/1.1", :path=>"/test", :args=>[["a", "1"], ["b", "two"]], "Accept-Encoding"=>"gzip;q=1.0,deflate;q=0.6,identity;q=0.3", "Accept"=>"*/*", "User-Agent"=>"Ruby", "Host"=>"localhost:6060"}|,
+                 reply, 'expected reply from GET')
+
+    # POST
+    uri = URI('http://localhost:6060/test')
+    response = Net::HTTP.post_form(uri, 'a' => '1', 'b' => 'two')
+    reply = response.body
+
+    assert_equal(%|{:id=>2, :method=>\"POST\", :protocol=>\"HTTP/1.1\", :path=>\"/test\", :args=>nil, \"Accept-Encoding\"=>\"gzip;q=1.0,deflate;q=0.6,identity;q=0.3\", \"Accept\"=>\"*/*\", \"User-Agent\"=>\"Ruby\", \"Host\"=>\"localhost:6060\", \"Content-Type\"=>\"application/x-www-form-urlencoded\", \"Content-Length\"=>9, :body=>\"a=1&b=two\"}|,
+                 reply, 'expected reply from POST')
+
+    ::OFlow::Env.flush()
+    ::OFlow::Env.clear()
+  end
+
+end # HttpServerTest

data/test/all_tests.rb

@@ -27,3 +27,4 @@ require 'actors/log_test'
 require 'actors/merger_test'
 require 'actors/persister_test'
 require 'actors/timer_test'
+require 'actors/httpserver_test'

data/test/flow_log_test.rb

@@ -17,7 +17,8 @@ class Noise < ::OFlow::Actor
   end
 
   def perform(op, box)
-    task.info("op: #{op}, box: #{box.contents}")
+    task.warn("op: #{op}, box: #{box.contents}")
+    task.ship(nil, ::OFlow::Box.new([box.contents])) if task.has_links?
   end
 
 end # Noise
@@ -28,6 +29,7 @@ class FlowLogTest < ::Test::Unit::TestCase
   def test_flow_log_relay
     trigger = nil
     collector = nil
+    ::OFlow::Env.log_level = Logger::WARN
     ::OFlow::Env.flow('log_relay') { |f|
       trigger = f.task('noise', Noise)
       f.task(:log, Collector) { |t|
@@ -48,7 +50,8 @@ class FlowLogTest < ::Test::Unit::TestCase
   def test_flow_log_var
     trigger = nil
     collector = nil
-    ::OFlow::Env.flow('log_relay') { |f|
+    ::OFlow::Env.log_level = Logger::WARN
+    ::OFlow::Env.flow('log_var') { |f|
       trigger = f.task('noise', Noise)
       f.log = f.task(:collector, Collector) { |t|
         collector = t.actor
@@ -59,7 +62,7 @@ class FlowLogTest < ::Test::Unit::TestCase
 
     assert_equal(collector.collection.size, 1)
     assert_equal(collector.collection[0][0], 'op: speak, box: 7')
-    assert_equal(collector.collection[0][1], ':log_relay:noise')
+    assert_equal(collector.collection[0][1], ':log_var:noise')
 
     ::OFlow::Env.clear()
   end
@@ -68,7 +71,8 @@ class FlowLogTest < ::Test::Unit::TestCase
   def test_flow_log_env
     trigger = nil
     collector = nil
-    ::OFlow::Env.flow('log_relay') { |f|
+    ::OFlow::Env.log_level = Logger::WARN
+    ::OFlow::Env.flow('log_env') { |f|
       trigger = f.task('noise', Noise)
       ::OFlow::Env.log = f.task(:collector, Collector) { |t|
         collector = t.actor
@@ -79,9 +83,40 @@ class FlowLogTest < ::Test::Unit::TestCase
 
     assert_equal(collector.collection.size, 1)
     assert_equal(collector.collection[0][0], 'op: speak, box: 7')
-    assert_equal(collector.collection[0][1], ':log_relay:noise')
+    assert_equal(collector.collection[0][1], ':log_env:noise')
+
+    ::OFlow::Env.clear()
+  end
+
+  def test_flow_log_info
+    trigger = nil
+    collector = nil
+    ::OFlow::Env.log_level = Logger::WARN
+    ::OFlow::Env.flow('log_info') { |f|
+      f.log = f.task(:collector, Collector) { |t|
+        collector = t.actor
+      }
+      # Set after log to avoid race condition with the creation of the collector
+      # and the assignment to f.log. The race is whether a log message is
+      # displayed on the output.
+      ::OFlow::Env.log_level = Logger::INFO
+      trigger = f.task('noise', Noise) { |t|
+        t.link(nil, :collector, nil)
+      }
+    }
+    trigger.receive(:speak, ::OFlow::Box.new(7))
+    ::OFlow::Env.flush()
+
+    entries = collector.collection.map { |entry| entry[0] }
+    assert_equal(["Creating actor Noise with options {:state=>1}.",
+                  "receive(speak, Box{7}) RUNNING",
+                  "perform(speak, Box{7})",
+                  "op: speak, box: 7",
+                  "shipping Box{[7]} to collector:",
+                  7], entries)
 
     ::OFlow::Env.clear()
+    ::OFlow::Env.log_level = Logger::WARN
   end
 
 end # FlowLogTest

data/test/flow_nest_test.rb

@@ -17,7 +17,7 @@ class Hop < ::OFlow::Actor
   end
 
   def perform(op, box)
-    task.info("#{op} #{box.contents}")
+    task.warn("#{op} #{box.contents}")
     task.ship(op, box)
   end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: oflow
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.6.0
 platform: ruby
 authors:
 - Peter Ohler
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-02-16 00:00:00.000000000 Z
+date: 2014-03-13 00:00:00.000000000 Z
 dependencies: []
 description: Operations Workflow in Ruby. This implements a workflow/process flow
   using multiple task nodes that each have their own queues and execution thread.
@@ -25,12 +25,14 @@ files:
 - lib/oflow/actors.rb
 - lib/oflow/actors/balancer.rb
 - lib/oflow/actors/errorhandler.rb
+- lib/oflow/actors/httpserver.rb
 - lib/oflow/actors/ignore.rb
 - lib/oflow/actors/log.rb
 - lib/oflow/actors/merger.rb
 - lib/oflow/actors/persister.rb
 - lib/oflow/actors/relay.rb
 - lib/oflow/actors/timer.rb
+- lib/oflow/actors/trigger.rb
 - lib/oflow/box.rb
 - lib/oflow/env.rb
 - lib/oflow/errors.rb
@@ -51,6 +53,7 @@ files:
 - lib/oflow/tracker.rb
 - lib/oflow/version.rb
 - test/actors/balancer_test.rb
+- test/actors/httpserver_test.rb
 - test/actors/log_test.rb
 - test/actors/merger_test.rb
 - test/actors/persister_test.rb
@@ -91,7 +94,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: oflow
-rubygems_version: 2.2.0
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: Operations Workflow in Ruby