newque 0.0.1

data/lib/newque/http/http_plaintext.rb

@@ -0,0 +1,66 @@
+require 'faraday'
+
+module Newque
+
+  class Http_plaintext
+    def initialize http
+      @http = http
+    end
+
+    def write channel, atomic, msgs, ids=nil
+      head, *tail = msgs
+      raise NewqueError.new("No messages given") if head.nil?
+
+      stream = StringIO.new
+      stream.write head
+      if msgs.size > 1
+        tail.each do |msg|
+          stream.write @http.options[:separator]
+          stream.write msg
+        end
+      end
+
+      thread = Thread.new do
+        res = @http.conn.post do |req|
+          @http.send :set_req_options, req
+          req.url "/v1/#{channel}"
+          req.body = stream.string
+
+          req.headers['newque-mode'] = if atomic then 'atomic'
+            elsif msgs.size == 1 then 'single'
+            else 'multiple'
+          end
+          req.headers['newque-msg-id'] = ids unless ids.nil?
+        end
+
+        parsed = @http.send :parse_json_response, res.body
+        Write_response.new parsed['saved']
+      end
+      Future.new thread, @http.timeout
+    end
+
+    def read channel, mode, limit=nil
+      thread = Thread.new do
+        res = @http.conn.get do |req|
+          @http.send :set_req_options, req
+          req.url "/v1/#{channel}"
+          req.headers['newque-mode'] = mode
+          req.headers['newque-read-max'] = limit unless limit.nil?
+        end
+        if res.status == 200
+          Read_response.new(
+            res.headers['newque-response-length'].to_i,
+            res.headers['newque-response-last-id'],
+            res.headers['newque-response-last-ts'].to_i,
+            res.body.split(@http.options[:separator])
+          )
+        else
+          @http.send :parse_json_response, res.body
+        end
+      end
+      Future.new thread, @http.timeout
+    end
+
+  end
+
+end

data/lib/newque/http/newque_http.rb

@@ -0,0 +1,116 @@
+require 'faraday'
+require 'net/http'
+
+module Newque
+
+  class Newque_http
+    extend Forwardable
+
+    BASE_OPTIONS = {
+      https: false,
+      http_format: :json,
+      separator: "\n"
+    }
+
+    def_delegators :@instance, :write, :read
+    attr_reader :conn, :options, :timeout
+
+    def initialize host, port, options, timeout
+      @host = host
+      @port = port
+      @options = Util.compute_options BASE_OPTIONS, options
+      @timeout = timeout / 1000.0
+
+      @conn = Faraday.new({ url: "#{@options[:https] ? "https" : "http"}://#{host}:#{port}" })
+
+      @instance = if @options[:http_format] == :json
+        Http_json.new self
+      elsif @options[:http_format] == :plaintext
+        Http_plaintext.new self
+      end
+    end
+
+    def read_stream channel, mode, limit=nil
+      Enumerator.new do |generator|
+        Net::HTTP.start(@host, @port) do |http|
+          req = Net::HTTP::Get.new "/v1/#{channel}"
+          req['newque-mode'] = mode
+          req['newque-read-max'] = limit unless limit.nil?
+          req['Transfer-Encoding'] = 'chunked'
+          http.open_timeout = @timeout
+          http.read_timeout = @timeout
+
+          http.request req do |res|
+            if res.code != '200'
+              generator << parse_json_response(res.body) # Will throw
+            else
+              leftover = nil
+              res.read_body do |chunk|
+                lines = "#{leftover || ''}#{chunk}".split(@options[:separator], -1)
+                *fulls, partial = lines
+                fulls.each do |msg|
+                  generator << msg
+                end
+                leftover = partial
+              end
+              generator << leftover unless leftover.nil?
+            end
+          end
+        end
+      end
+    end
+
+    def count channel
+      thread = Thread.new do
+        res = @conn.get do |req|
+          set_req_options req
+          req.url "/v1/#{channel}/count"
+        end
+        parsed = parse_json_response res.body
+        Count_response.new parsed['count']
+      end
+      Future.new thread, @timeout
+    end
+
+    def delete channel
+      thread = Thread.new do
+        res = @conn.delete do |req|
+          set_req_options req
+          req.url "/v1/#{channel}"
+        end
+        parsed = parse_json_response res.body
+        Delete_response.new
+      end
+      Future.new thread, @timeout
+    end
+
+    def health channel, global=false
+      thread = Thread.new do
+        res = @conn.get do |req|
+          set_req_options req
+          req.url "/v1#{global ? '' : '/' + channel}/health"
+        end
+        parsed = parse_json_response res.body
+        Health_response.new
+      end
+      Future.new thread, @timeout
+    end
+
+    private
+
+    def set_req_options req
+      req.options.open_timeout = @timeout
+      req.options.timeout = @timeout
+    end
+
+    def parse_json_response body
+      parsed = JSON.parse body
+      if parsed['errors'].size > 0
+        raise Util.newque_error parsed['errors']
+      end
+      parsed
+    end
+
+  end
+
+end

data/lib/newque/responses.rb

@@ -0,0 +1,219 @@
+require 'json'
+
+module Newque
+
+  # ------------------------------------
+  # REQUESTS
+  # ------------------------------------
+  class Write_request
+    attr_reader :atomic, :ids
+
+    def initialize atomic, ids
+      @atomic = atomic
+      @ids = ids
+    end
+
+    def to_s
+      "<Write atomic: #{@atomic.to_json} ids: #{@ids.to_json}>"
+    end
+
+    def inspect
+      to_s
+    end
+  end
+
+  class Read_request
+    attr_reader :mode, :limit
+
+    def initialize mode, limit
+      @mode = mode
+      @limit = limit
+    end
+
+    def to_s
+      "<Read mode: #{@mode.to_json} limit: #{@limit.to_json}>"
+    end
+
+    def inspect
+      to_s
+    end
+  end
+
+  class Count_request
+    def initialize
+    end
+
+    def to_s
+      "<Count >"
+    end
+
+    def inspect
+      to_s
+    end
+  end
+
+  class Delete_request
+    def initialize
+    end
+
+    def to_s
+      "<Delete >"
+    end
+
+    def inspect
+      to_s
+    end
+  end
+
+  class Health_request
+    attr_reader :global
+
+    def initialize global
+      @global = global
+    end
+
+    def to_s
+      "<Health global: #{@global.to_json}>"
+    end
+
+    def inspect
+      to_s
+    end
+  end
+
+  class Input_request
+    attr_reader :channel, :action, :messages
+
+    def initialize channel, action, messages
+      @channel = channel
+      @action = action
+      @messages = messages
+    end
+
+    def to_s
+      "<Newque_input channel: #{channel.to_json} action: #{@action} #{@messages.size > 0 ? 'messages: ' + @messages.to_json : ''}>"
+    end
+
+    def inspect
+      to_s
+    end
+  end
+
+  # ------------------------------------
+  # RESPONSES
+  # ------------------------------------
+  class Write_response
+    attr_reader :saved
+
+    def initialize saved
+      @saved = saved
+    end
+
+    def to_s
+      "<Newque_write saved: #{saved.to_json}>"
+    end
+
+    def inspect
+      to_s
+    end
+
+    def serialize
+      {
+        write_output: Write_Output.new(saved: @saved),
+        messages: []
+      }
+    end
+  end
+
+  class Read_response
+    attr_reader :length, :last_id, :last_timens, :messages
+
+    def initialize length, last_id, last_timens, messages
+      @length = length
+      @last_id = last_id
+      @last_timens = last_timens
+      @messages = messages
+    end
+
+    def to_s
+      "<Newque_read length: #{length.to_json} last_id: #{last_id.to_json} last_timens: #{last_timens.to_json} messages: #{messages}>"
+    end
+
+    def inspect
+      to_s
+    end
+
+    def serialize
+      {
+        read_output: Read_Output.new(length: @length, last_id: @last_id, last_timens: @last_timens),
+        messages: @messages
+      }
+    end
+  end
+
+  class Count_response
+    attr_reader :count
+
+    def initialize count
+      @count = count
+    end
+
+    def to_s
+      "<Newque_count count: #{count.to_json}>"
+    end
+
+    def inspect
+      to_s
+    end
+
+    def serialize
+      {
+        count_output: Count_Output.new(count: @count),
+        messages: []
+      }
+    end
+  end
+
+  class Delete_response
+
+    def initialize
+    end
+
+    def to_s
+      "<Newque_delete >"
+    end
+
+    def inspect
+      to_s
+    end
+
+    def serialize
+      {
+        delete_output: Delete_Output.new,
+        messages: []
+      }
+    end
+  end
+
+  class Health_response
+
+    def initialize
+    end
+
+    def to_s
+      "<Newque_health >"
+    end
+
+    def inspect
+      to_s
+    end
+
+    def serialize
+      {
+        health_output: Health_Output.new,
+        messages: []
+      }
+    end
+  end
+
+end

data/lib/newque/util.rb

@@ -0,0 +1,42 @@
+module Newque
+
+  class Util
+
+    def self.compute_options base_options, options
+      Hash[
+        base_options.map do |name, default_value|
+          [name, (options[name].nil? ? default_value : options[name])]
+        end
+      ]
+    end
+
+    def self.time_ms
+      (Time.now.to_f * 1000).to_i
+    end
+
+    def self.newque_error errors
+      NewqueError.new "Client Error#{errors.size > 1 ? 's' : ''}: #{errors.join(', ')}"
+    end
+
+    def self.zmq_error error
+      NewqueError.new "Network Error: #{error}"
+    end
+
+    def self.wait_t
+      t = Thread.new do
+        while Thread.current.thread_variable_get(:result).nil?
+          sleep 0
+        end
+        Thread.current.thread_variable_get(:result)
+      end
+      t.priority = -1
+      t
+    end
+
+    def self.resolve_t thread, result
+      thread.thread_variable_set(:result, result)
+    end
+
+  end
+
+end

data/lib/newque/version.rb

@@ -0,0 +1,3 @@
+module Newque
+  VERSION = "0.0.1"
+end