pubcontrol 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 852c3861e8aad560d515e5c32f117c48956e22a3
+  data.tar.gz: b63b17e203c3aa21f12371103d44a4b4ea57835e
+SHA512:
+  metadata.gz: 3a470816b50c288d8f5ae5eee40c002bdcea7031f42afb2c843953e559da762190e9915c2fe587c88d35a7ceaf1ecf6593c68e11ac49bf21e146609f2daf44a7
+  data.tar.gz: ec30846c776afae6ea6a34c11fcbb10fc781e5360b385509ed2a8742ece70f94d340270cec2b353560cf25c2a725879ceb2051663d5b6ce078e587932bd07d1f

data/lib/format.rb

@@ -0,0 +1,15 @@
+#    format.rb
+#    ~~~~~~~~~
+#    This module implements the Format class.
+#    :copyright: (c) 2014 by Konstantin Bokarius.
+#    :license: MIT, see LICENSE for more details.
+
+class Format
+  def name
+    raise NotImplementedError
+  end
+
+  def export
+    raise NotImplementedError
+  end
+end

data/lib/item.rb

@@ -0,0 +1,32 @@
+#    item.rb
+#    ~~~~~~~~~
+#    This module implements the Item class.
+#    :copyright: (c) 2014 by Konstantin Bokarius.
+#    :license: MIT, see LICENSE for more details.
+
+require_relative 'format.rb'
+
+class Item
+  def initialize(formats, id=nil, prev_id=nil)
+    @id = id
+    @prev_id = prev_id
+    if formats.is_a? Format
+      formats = [formats]
+    end
+    @formats = formats
+  end
+
+  def export
+    out = Hash.new
+    if !@id.nil?
+      out['id'] = @id
+    end
+    if !@prev_id.nil?
+      out['prev-id'] = @prev_id
+    end
+    @formats.each do |format|
+      out[format.name] = format.export
+    end
+    return out
+  end
+end

data/lib/pccbhandler.rb

@@ -0,0 +1,30 @@
+#    format.rb
+#    ~~~~~~~~~
+#    This module implements the PubControlCallbackHandler class.
+#    :copyright: (c) 2014 by Konstantin Bokarius.
+#    :license: MIT, see LICENSE for more details.
+
+class PubControlCallbackHandler
+  def initialize(num_calls, callback)
+    @num_calls = num_calls
+    @callback = callback
+    @success = true
+    @first_error_message = nil
+  end
+
+  def handler(success, message)
+    if !success and @success
+      @success = false
+      @first_error_message = message
+    end
+    @num_calls -= 1
+    if @num_calls <= 0
+      @callback.call(@success, @first_error_message)
+    end
+  end
+
+  # TODO: how to get handler symbol without this method?
+  def handler_method_symbol
+    return method(:handler)
+  end
+end

data/lib/pubcontrol.rb

@@ -0,0 +1,196 @@
+#    pubcontrol.rb
+#    ~~~~~~~~~
+#    This module implements the PubControl class.
+#    :copyright: (c) 2014 by Konstantin Bokarius.
+#    :license: MIT, see LICENSE for more details.
+
+require 'algorithms'
+require 'thread'
+require 'base64'
+require 'jwt'
+require 'json'
+require 'net/http'
+require_relative 'item.rb'
+require_relative 'format.rb'
+require_relative 'pubcontrolset.rb'
+
+class PubControl
+  attr_accessor :req_queue
+
+  def initialize(uri)
+    @uri = uri
+    @lock = Mutex.new
+    @thread = nil
+    @thread_cond = nil
+    @thread_mutex = nil
+    @req_queue = Containers::Deque.new
+    @auth_basic_user = nil
+    @auth_basic_pass = nil
+    @auth_jwt_claim = nil
+    @auth_jwt_key = nil
+  end
+
+  def set_auth_basic(username, password)
+    @lock.synchronize do
+      @auth_basic_user = username
+      @auth_basic_pass = password
+    end
+  end
+
+  def set_auth_jwt(claim, key)
+    @lock.synchronize do
+      @auth_jwt_claim = claim
+      @auth_jwt_key = key
+    end
+  end
+
+  def publish(channel, item)
+    export = item.export
+    export['channel'] = channel
+    uri = nil
+    auth = nil
+    @lock.synchronize do
+      uri = @uri
+      auth = gen_auth_header
+    end
+    PubControl.pubcall(uri, auth, [export])
+  end
+
+  def publish_async(channel, item, callback=nil)
+    export = item.export
+    export['channel'] = channel
+    uri = nil
+    auth = nil
+    @lock.synchronize do
+      uri = @uri
+      auth = gen_auth_header
+      ensure_thread
+    end
+    queue_req(['pub', uri, auth, export, callback])
+  end
+
+  def finish
+    @lock.synchronize do
+      if !@thread.nil?
+        queue_req(['stop'])
+        @thread.join
+        @thread = nil
+      end
+    end
+  end
+
+  def pubworker
+    quit = false
+    while !quit do
+      @thread_mutex.lock
+      if @req_queue.length == 0
+        @thread_cond.wait(@thread_mutex)
+        if @req_queue.length == 0
+          @thread_mutex.unlock
+          next
+        end
+      end
+      reqs = Array.new
+      while @req_queue.length > 0 and reqs.length < 10 do
+        m = @req_queue.pop_front
+        if m[0] == 'stop'
+          quit = true
+          break
+        end
+        reqs.push([m[1], m[2], m[3], m[4]])
+      end
+      @thread_mutex.unlock
+      if reqs.length > 0
+        PubControl.pubbatch(reqs)
+      end
+    end
+  end
+
+  def self.pubcall(uri, auth_header, items)
+    uri = URI(uri + '/publish/')
+    content = Hash.new
+    content['items'] = items
+    # REVIEW: POST implementation
+    request = Net::HTTP::Post.new(uri.path)
+    # REVIEW: Ruby strings are unicode by default
+    # is forcing the encoding to UTF-8 necessary?
+    request.body = content.to_json.force_encoding('UTF-8')
+    if !auth_header.nil?
+      request['Authorization'] = auth_header
+    end
+    request['Content-Type'] = 'application/json'
+    response = Net::HTTP.start(uri.host, use_ssl: true) do |http|
+      http.request(request)
+    end
+    # REVIEW: HTTPSuccess does not include 3xx status codes.
+    if !response.kind_of? Net::HTTPSuccess
+      raise 'failed to publish: ' + response.class.to_s + ' ' +
+          response.message
+    end
+  end
+
+  def self.pubbatch(reqs)
+    raise 'reqs length == 0' unless reqs.length > 0
+    uri = reqs[0][0]
+    auth_header = reqs[0][1]
+    items = Array.new
+    callbacks = Array.new
+    reqs.each do |req|
+      items.push(req[2])
+      callbacks.push(req[3])
+    end
+    begin
+      PubControl.pubcall(uri, auth_header, items)
+      result = [true, '']
+    rescue => e
+      result = [false, e.message]
+    end
+    callbacks.each do |callback|
+      if !callback.nil?
+        callback.call(result[0], result[1])
+      end
+    end
+  end
+
+  def self.timestamp_utcnow
+    # REVIEW: gmtime Ruby implementation
+    return Time.now.utc.to_i
+  end
+
+  private
+
+  def gen_auth_header
+    if !@auth_basic_user.nil?
+      return 'Basic ' + Base64.encode64(
+          '#{@auth_basic_user}:#{@auth_basic_pass}')
+    elsif !@auth_jwt_claim.nil?
+      if !@auth_jwt_claim.has_key?('exp')
+        claim = @auth_jwt_claim.clone
+        claim['exp'] = PubControl.timestamp_utcnow + 3600
+      else
+        claim = @auth_jwt_claim
+      end
+      return 'Bearer ' + JWT.encode(claim, @auth_jwt_key)
+    else
+      return None
+    end
+  end
+
+  def ensure_thread
+    if @thread.nil?
+      @thread_cond = ConditionVariable.new
+      @thread_mutex = Mutex.new
+      @thread = Thread.new { pubworker }
+      # REVIEW: Ruby threads are daemonic by default 
+      #@thread.daemon = true
+    end
+  end
+
+  def queue_req(req)
+    # REVIEW: thread condition implementation
+    @thread_mutex.lock
+    @req_queue.push_back(req)
+    @thread_cond.signal
+    @thread_mutex.unlock
+  end
+end

data/lib/pubcontrolset.rb

@@ -0,0 +1,71 @@
+#    pubcontrolset.rb
+#    ~~~~~~~~~
+#    This module implements the PubControlSet class.
+#    :copyright: (c) 2014 by Konstantin Bokarius.
+#    :license: MIT, see LICENSE for more details.
+
+require_relative 'pubcontrol.rb'
+require_relative 'pccbhandler.rb'
+
+class PubControlSet
+  def initialize
+    @pubs = Array.new
+    at_exit { finish }
+  end
+
+  def clear
+    @pubs = Array.new
+  end
+
+  def add(pub)
+    @pubs.push(pub)
+  end
+
+  def apply_config(config)
+    config.each do |entry|
+      pub = PubControl.new(entry['uri'])
+      if entry.key?('iss')
+        pub.set_auth_jwt({'iss' => entry['iss']}, entry['key'])
+      end
+      @pubs.push(pub)
+    end
+  end
+
+  def apply_grip_config(config)
+    config.each do |entry|
+      if !entry.key?('control_uri')
+        next
+      end
+      pub = PubControl.new(entry['control_uri'])
+      if !entry.key?('control_iss')
+        pub.set_auth_jwt({'iss' => entry['control_iss']}, entry['key'])
+      end
+      @pubs.push(pub)
+    end
+  end
+
+  def publish(channel, item, blocking=false, callback=nil)
+    if blocking
+      @pubs.each do |pub|
+        pub.publish(channel, item)
+      end
+    else
+      cb = nil
+      if !callback.nil?
+        cb = PubControlCallbackHandler.new(@pubs.length, callback).
+            handler_method_symbol
+      end
+      @pubs.each do |pub|
+        pub.publish_async(channel, item, cb)
+      end
+    end
+  end
+
+  private
+
+  def finish
+    @pubs.each do |pub|
+      pub.finish
+    end
+  end
+end

metadata

@@ -0,0 +1,48 @@
+--- !ruby/object:Gem::Specification
+name: pubcontrol
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Konstantin Bokarius
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-01-02 00:00:00.000000000 Z
+dependencies: []
+description: A Ruby implementation of the EPCP protocol.
+email: bokarius@comcast.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/format.rb
+- lib/item.rb
+- lib/pccbhandler.rb
+- lib/pubcontrol.rb
+- lib/pubcontrolset.rb
+homepage: http://rubygems.org/gems/pubcontrol
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Ruby EPCP library
+test_files: []