rbkubemq 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 1465b9f1b680dbfed9cd00005a31d0f41744cdb9054e25a9d173b1a8a90e9e3c
+  data.tar.gz: ef45fd425d388d4147f6d16d03f078e8ca32840b7e0f0eaae108170cdc96ab0b
+SHA512:
+  metadata.gz: 1f906a81a3a80b0f6df9f9c3801c0e9ebcb31828352c14d642ed27fd48ba684f65823eee0cf6f32a3b3795e5f3b806f9d80370b218c51f379929091b5a965c43
+  data.tar.gz: 8de80c39260cf3a81487d73e5c99ef9f667815feef7722bcdc4f4fffd689504c2c2d5325639fe32ce0ba9c63cba52fa803820de6b5846b0a64b75a1b9b9d90e3

data/Gemfile

@@ -0,0 +1,12 @@
+
+source "https://rubygems.org"
+
+gem "httparty",  "~>0.16.4"
+gem "oj",  "~>3.7.11"
+gem "faye-websocket", "~>0.10.7"
+
+group :development, :test do
+	gem "rspec"
+	gem "pry-byebug"
+	gem "eventmachine"
+end

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 Seluxit
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/RBKubeMQ.gemspec

@@ -0,0 +1,20 @@
+# lib = File.expand_path('../lib', __FILE__)
+# $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "rake"
+
+Gem::Specification.new do |s|
+  s.name        = 'rbkubemq'
+  s.version	    = '0.0.1'
+  s.authors     = ['Stefano Martin']
+  s.email       = ['stefano@seluxit.com']
+  s.homepage    = 'https://github.com/StefanoMartin/RBKubeMQ'
+  s.license     = 'MIT'
+  s.summary     = 'A simple gem for KubeMQ'
+  s.description = "Ruby driver for RBKubeMQ"
+  s.platform	   = Gem::Platform::RUBY
+  s.require_paths = ['lib']
+  s.files         = FileList['lib/**/*', 'RBKubeMQ.gemspec', 'Gemfile', 'LICENSE', 'README.md'].to_a
+  s.add_dependency 'httparty', '~> 0.14', '>= 0.14.0'
+  s.add_dependency 'oj', '~> 3.6.11', '>=  3.6.11'
+  s.add_dependency 'faye-websocket', '~> 0.10.7', '>=  0.10.7'
+end

data/README.md

@@ -0,0 +1,131 @@
+This is a quick gem created for manage [KubeMQ](https://kubemq.io/) with Ruby.
+
+It requires the gems "HTTParty", "Oj" and "faye-websocket".
+
+To install ArangoRB: `gem install RBKubeMQ`.
+
+To use it in your application: `require rbkubemq`.
+
+For examples, look the tests in "/spec/lib/spec_helper"
+
+## Classes used
+
+* [RBKubeMQ::Client](#RKMQCLient): to manage a general client
+* [RBKubeMQ::Sender](#RKMQSender): to manage a sender
+* [RBKubeMQ::Streamer](#RKMQStreamer): to create a websocket to send data
+* [RBKubeMQ::Subscriber](#RKMQsubscriber): to create a websocket to receive data
+* [RBKubeMQ::Utility](#RKMQutility): to parse and load easier the data
+* [RBKubeMQ::Error](#RKMQerror): to manage generic error
+
+<a name="RKMQCLient"></a>
+## RBKubeMQ::Client
+
+Arango::Server is used to manage a connection with KubeMQ.
+
+``` ruby
+client = RBKubeMQ::Client.new host: "YOUR_HOST", port: "8080", tls: false # tls is true then it will make your requests with https and wss instead of http or ws
+```
+
+<a name="RKMQSender"></a>
+## RBKubeMQ::Sender
+
+Sender it is used to do HTTP requests to KubeMQ. It manage event, request, query and response requests.
+
+``` ruby
+sender = client.sender client_id: "YOUR_CLIENT", channel: "YOUR_CHANNEL",
+meta: nil, store: false, timeout: 1000, cache_key: nil, cache_ttl: nil
+```
+
+The possible request that you can do are the following:
+
+``` ruby
+sender.event("YOUR MESSAGE") # send an event
+sender.request("YOUR MESSAGE") # send a request (we do not expect a body)
+sender.query("YOUR MESSAGE") # send a query  (we expect a body)
+sender.response(received_request, message: "YOUR MESSAGE") # send a response to a request (the received request is the one received with a subscriber)
+```
+
+You can overwrite the default values by inserting them as attributes, like this:
+
+``` ruby
+sender.event("YOUR MESSAGE", client_id: "client_id")
+```
+
+Note that client_id, channel are mandatory values that need to be insert either at the initialization or during the request.
+
+<a name="RKMQStreamer"></a>
+## RBKubeMQ::Streamer
+
+Streamer it is used to create a stream websocket that it will be used to communicate with the KubeMQ. By using an eventmachine the structure of a streamer can be similar to one of a websocket.
+
+```ruby
+i = 0
+EM.run do
+  streamer = client.streamer(client_id: "YOUR_CLIENT", channel: "YOUR_CHANNEL",
+    meta: nil, store: false)
+  ws = streamer.start # Create a websocket by starting it
+
+  ws.on :open do |event|
+    p [:open]
+  end
+
+  ws.on :message do |event|
+    p [:message, RBKubeMQ::Utility.load(event.data)]
+  end
+
+  ws.on :close do |event|
+    p [:close]
+    ws = nil; EM.stop
+  end
+
+  # Send a message every second
+  timer = EM::PeriodicTimer.new(1) do
+    i += 1
+    puts "SENDING #{i}"
+    streamer.send(i, meta: "Stream") # Note that we use streamer and not ws to send the stream
+  end
+end
+```
+
+<a name="RKMQSubscriber"></a>
+## RBKubeMQ::Subscriber
+
+Subscriber is liked the streamer but it is used only to subscribe to a client_id and a channel. You can use groups to subdivide the queue between different machines.
+It cannot be use to send data.
+
+```ruby
+EM.run do
+  subscriber = client.subscriber(client_id: "YOUR_CLIENT", channel: "YOUR_CHANNEL",
+    group: "YOUR_GROUP")
+  ws = subscriber.events
+
+  ws.on :open do |event|
+    p [:open]
+  end
+
+  ws.on :message do |event|
+    p [:message, RBKubeMQ::Utility.load(event.data)]
+  end
+
+  ws.on :close do |event|
+    p [:close]
+    ws = nil; EM.stop
+  end
+end
+```
+
+In the example the subscriber is for events.
+You can subscribe to "events_store", "requests", and "queries".
+
+<a name="RKMQUtility"></a>
+## RBKubeMQ::Utility
+
+```ruby
+RBKubeMQ::Utility.dump(hash) # Convert hash in correct format for KubeMQ
+RBKubeMQ::Utility.load(string) # Parse hash in human format from KubeMQ
+```
+
+<a name="RKMQerror"></a>
+## RBKubeMQ::Error
+
+RBKubeMQ::Error is used to manage generic errors inside of the gem.

data/lib/client.rb

@@ -0,0 +1,35 @@
+module RBKubeMQ
+  class Client
+    include Check
+
+    def initialize(host:, port: "9090", tls: false)
+      @host = host
+      @port = port
+      is_class?(tls, [FalseClass, TrueClass], "tls")
+      @tls  = tls
+      @uri = "http"
+      @uri += "s" if @tls
+      @uri += "://#{host}:#{port}"
+      @ws = "ws"
+      @ws += "s" if @tls
+      @ws += "://#{host}:#{port}"
+    end
+
+    attr_reader :host, :port, :uri, :tls, :ws
+
+    def sender(*args)
+      args[0][:client] = self if args[0].is_a?(Hash)
+      RBKubeMQ::Sender.new(args[0])
+    end
+
+    def streamer(*args)
+      args[0][:client] = self if args[0].is_a?(Hash)
+      RBKubeMQ::Streamer.new(args[0])
+    end
+
+    def subscriber(*args)
+      args[0][:client] = self if args[0].is_a?(Hash)
+      RBKubeMQ::Subscriber.new(args[0])
+    end
+  end
+end

data/lib/errors.rb

@@ -0,0 +1,4 @@
+module RBKubeMQ
+  class Error < StandardError
+  end
+end

data/lib/helpers/check.rb

@@ -0,0 +1,8 @@
+module RBKubeMQ
+  module Check
+    def is_class?(object, classes, name)
+      return if classes.include?(object.class)
+      raise RBKubeMQ::Error.new("#{name} should be #{classes.map(&:to_s).join(", ")}")
+    end
+  end
+end

data/lib/helpers/utility.rb

@@ -0,0 +1,20 @@
+module RBKubeMQ
+  class Utility
+    def self.dump(hash)
+      hash.compact!
+      hash["Body"] = Base64.encode64(hash["Body"].to_s)
+      Oj.dump(hash, mode: :json)
+    end
+
+    def self.load(hash)
+      hash = Oj.load(hash) if hash.is_a?(String)
+      unless hash["Body"].nil?
+        hash["Body"] = Base64.decode64(hash["Body"].to_s)
+      end
+      if hash["data"].is_a?(Hash) && !hash["data"]["Body"].nil?
+        hash["data"]["Body"] = Base64.decode64(hash["data"]["Body"].to_s)
+      end
+      hash
+    end
+  end
+end

data/lib/rbkubemq.rb

@@ -0,0 +1,13 @@
+require "httparty"
+require "oj"
+require "faye/websocket"
+require "base64"
+require 'ostruct'
+
+require_relative "helpers/check"
+require_relative "helpers/utility"
+require_relative "client"
+require_relative "errors"
+require_relative "sender"
+require_relative "streamer"
+require_relative "subscriber"

data/lib/sender.rb

@@ -0,0 +1,102 @@
+module RBKubeMQ
+  class Sender
+    include Check
+    @@response = Struct.new(:code, :body)
+
+    HEADER = {"Content-Type" => "application/json"}
+
+    def initialize(client:, client_id: nil, channel: nil, meta: nil, store: false,
+      timeout: 5000, cache_key: nil, cache_ttl: nil)
+      is_class?(client, [RBKubeMQ::Client], "client")
+      @client     = client
+      @client_id  = client_id
+      @channel    = channel
+      @meta       = meta.nil? ? meta : meta.to_s
+      @store      = store
+      @timeout    = timeout
+      @cache_key   = cache_key
+      @cache_ttl   = cache_ttl
+    end
+
+    def event(message, meta: @meta, store: @store, client_id: @client_id,
+        channel: @channel, id: nil)
+      body = {
+        "EventID" => id,
+        "ClientID" => client_id,
+        "Channel" => channel,
+        "Metadata" => meta,
+        "Body" => message,
+        "Store" => store
+      }
+      http = HTTParty.post("#{@client.uri}/send/event", headers: HEADER,
+        body: RBKubeMQ::Utility.dump(body))
+      @@response.new(http.code, RBKubeMQ::Utility.load(http.parsed_response))
+    rescue StandardError => e
+      raise RBKubeMQ::Error.new(e.message)
+    end
+
+    def request(message, meta: @meta, store: @store, client_id: @client_id,
+        channel: @channel, id: nil, timeout: @timeout)
+      body = {
+        "RequestID" => id,
+        "RequestTypeData" => 1,
+        "ClientID" => client_id,
+        "Channel" => channel,
+        "Metadata" => meta,
+        "Body" => message,
+        "Timeout" => timeout
+      }
+      http = HTTParty.post("#{@client.uri}/send/request", headers: HEADER,
+        body: RBKubeMQ::Utility.dump(body))
+      @@response.new(http.code, RBKubeMQ::Utility.load(http.parsed_response))
+    rescue StandardError => e
+      raise RBKubeMQ::Error.new(e.message)
+    end
+
+    def query(message, meta: @meta, store: @store, client_id: @client_id,
+        channel: @channel, id: nil, timeout: @timeout, cache_key: @cache_key,
+        cache_ttl: @cache_ttl)
+      body = {
+        "RequestID" => id,
+        "RequestTypeData" => 2,
+        "ClientID" => client_id,
+        "Channel" => channel,
+        "Metadata" => meta,
+        "Body" => message,
+        "Timeout" => timeout,
+        "CacheKey" => cache_key,
+        "CacheTTL" => cache_ttl
+      }
+      http = HTTParty.post("#{@client.uri}/send/request", headers: HEADER,
+        body: RBKubeMQ::Utility.dump(body))
+      @@response.new(http.code, RBKubeMQ::Utility.load(http.parsed_response))
+    rescue StandardError => e
+      raise RBKubeMQ::Error.new(e.message)
+    end
+
+    def response(request, message: nil, executed: true, error: nil, meta: @meta,
+      client_id: @client_id)
+      unless request.is_a?(Hash)
+        request = RBKubeMQ::Utility.load(request)
+      end
+
+      body = {
+        "RequestID" => request["RequestID"],
+        "ClientID" => client_id,
+        "ReplyChannel" => request["ReplyChannel"],
+        "Executed" => executed,
+        "Error" => error
+      }
+      if request["RequestTypeData"] == 2
+        body["Metadata"] = meta
+        body["Body"] = message
+      end
+
+      http = HTTParty.post("#{@client.uri}/send/response", headers: HEADER,
+        body: RBKubeMQ::Utility.dump(body))
+      @@response.new(http.code, RBKubeMQ::Utility.load(http.parsed_response))
+    rescue StandardError => e
+      raise RBKubeMQ::Error.new(e.message)
+    end
+  end
+end

data/lib/streamer.rb

@@ -0,0 +1,36 @@
+module RBKubeMQ
+  class Streamer
+    include Check
+
+    def initialize(client:, client_id: nil, channel: nil, meta: nil, store: false)
+      is_class?(client, [RBKubeMQ::Client], "client")
+      @client = client
+      @client_id  = client_id
+      @channel = channel
+      @meta    = meta.nil? ? meta.to_s : meta
+      @store = store
+    end
+
+    attr_accessor :client_id, :channel, :meta, :store
+
+    def start
+      @ws = Faye::WebSocket::Client.new("#{@client.ws}/send/stream")
+      @ws
+    end
+
+    def send(message, meta: @meta, store: @store, client_id: @client_id,
+        channel: @channel, id: nil)
+      body = {
+        "EventID" => id,
+        "ClientID" => client_id,
+        "Channel" => channel,
+        "Metadata" => meta,
+        "Body" => message,
+        "Store" => store
+      }
+      @ws.send(RBKubeMQ::Utility.dump(body))
+    rescue StandardError => e
+      raise RBKubeMQ::Error.new(e.message)
+    end
+  end
+end

data/lib/subscriber.rb

@@ -0,0 +1,53 @@
+module RBKubeMQ
+  class Subscriber
+    include Check
+
+    def initialize(client:, client_id: nil, channel: nil, group: nil,
+      events_store_type_data: 1, events_store_type_value: nil)
+      is_class?(client, [RBKubeMQ::Client], "client")
+      @client = client
+      @client_id  = client_id
+      @channel = channel
+      @group = group
+      @events_store_type_data = events_store_type_data
+      @events_store_type_value = events_store_type_value
+    end
+
+    attr_accessor :client_id, :channel, :meta, :store, :group,
+      :events_store_type_data, :events_store_type_value
+
+    def events
+      url = "#{@client.ws}/subscribe/events?client_id=#{@client_id}&channel=#{@channel}"
+      url += "&group=#{@group}" unless @group.nil?
+      url += "&subscribe_type=events"
+      @ws = Faye::WebSocket::Client.new(url)
+      @ws
+    end
+
+    def events_store
+      url = "#{@client.ws}/subscribe/events?client_id=#{@client_id}&channel=#{@channel}"
+      url += "&group=#{@group}" unless @group.nil?
+      url += "&events_store_type_data=#{@events_store_type_data}"
+      url += "&events_store_type_value=#{@events_store_type_value}" unless @events_store_type_value.nil?
+      url += "&subscribe_type=events_store"
+      @ws = Faye::WebSocket::Client.new(url)
+      @ws
+    end
+
+    def requests
+      url = "#{@client.ws}/subscribe/requests?client_id=#{@client_id}&channel=#{@channel}"
+      url += "&group=#{@group}" unless @group.nil?
+      url += "&subscribe_type=commands"
+      @ws = Faye::WebSocket::Client.new(url)
+      @ws
+    end
+
+    def queries
+      url = "#{@client.ws}/subscribe/requests?client_id=#{@client_id}&channel=#{@channel}"
+      url += "&group=#{@group}" unless @group.nil?
+      url += "&subscribe_type=queries"
+      @ws = Faye::WebSocket::Client.new(url)
+      @ws
+    end
+  end
+end

metadata

@@ -0,0 +1,116 @@
+--- !ruby/object:Gem::Specification
+name: rbkubemq
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Stefano Martin
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-04-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: httparty
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.14'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.14.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.14'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.14.0
+- !ruby/object:Gem::Dependency
+  name: oj
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.6.11
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.6.11
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.6.11
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.6.11
+- !ruby/object:Gem::Dependency
+  name: faye-websocket
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.10.7
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.10.7
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.10.7
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.10.7
+description: Ruby driver for RBKubeMQ
+email:
+- stefano@seluxit.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- LICENSE
+- RBKubeMQ.gemspec
+- README.md
+- lib/client.rb
+- lib/errors.rb
+- lib/helpers/check.rb
+- lib/helpers/utility.rb
+- lib/rbkubemq.rb
+- lib/sender.rb
+- lib/streamer.rb
+- lib/subscriber.rb
+homepage: https://github.com/StefanoMartin/RBKubeMQ
+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.7.7
+signing_key: 
+specification_version: 4
+summary: A simple gem for KubeMQ
+test_files: []