nsq-krakow 0.1.0

data/lib/krakow/producer/http.rb

@@ -0,0 +1,224 @@
+require 'http'
+require 'uri'
+require 'ostruct'
+
+require 'cgi'
+# NOTE: Prevents weird "first" run behavior
+begin
+  require 'json'
+rescue LoadError
+  # ignore (maybe log?)
+end
+
+require 'krakow'
+
+module Krakow
+  class Producer
+
+    # HTTP based producer
+    class Http
+
+      include Utils::Lazy
+      # @!parse include Krakow::Utils::Lazy::InstanceMethods
+      # @!parse extend Krakow::Utils::Lazy::ClassMethods
+
+      # Wrapper for HTTP response hash
+      class Response < OpenStruct
+      end
+
+      attr_reader :uri
+
+      # @!group Attributes
+
+      # @!macro [attach] attribute
+      #   @!method $1
+      #     @return [$2] the $1 $0
+      #   @!method $1?
+      #     @return [TrueClass, FalseClass] truthiness of the $1 $0
+      attribute :endpoint, String, :required => true
+      attribute :topic, String, :required => true
+      attribute :config, Hash, :default => ->{ Hash.new }
+      attribute :ssl_context, Hash
+
+      # @!endgroup
+
+      def initialize(args={})
+        super
+        build_ssl_context if ssl_context
+        @uri = URI.parse(endpoint)
+      end
+
+      # Create a new SSL context
+      #
+      # @return [OpenSSL::SSL::SSLContext]
+      def build_ssl_context
+        require 'openssl'
+        context = OpenSSL::SSL::SSLContext.new
+        context.cert = OpenSSL::X509::Certificate.new(File.open(ssl_context[:certificate]))
+        context.key = OpenSSL::PKey::RSA.new(File.open(ssl_context[:key]))
+        config[:ssl_context] = context
+      end
+
+      # Send a message via HTTP
+      #
+      # @param method [String, Symbol] HTTP method to use (:get, :put, etc)
+      # @param path [String] URI path
+      # @param args [Hash] payload hash
+      # @return [Response]
+      def send_message(method, path, args={})
+        build = uri.dup
+        build.path = "/#{path}"
+        response = HTTP.send(method, build.to_s, args.merge(config))
+        begin
+          response = MultiJson.load(response.body.to_s)
+        rescue MultiJson::LoadError
+          response = {
+            'status_code' => response.code,
+            'status_txt' => response.body.to_s,
+            'response' => response.body.to_s,
+            'data' => nil,
+          }
+        end
+        Response.new(response)
+      end
+
+      # Send messages
+      #
+      # @param payload [String] message
+      # @return [Response]
+      def write(*payload)
+        if(payload.size == 1)
+          payload = payload.first
+          send_message(:post, :pub,
+            :body => payload,
+            :params => {:topic => topic}
+          )
+        else
+          send_message(:post, :mpub,
+            :body => payload.join("\n"),
+            :params => {:topic => topic}
+          )
+        end
+      end
+
+      # Create the topic
+      #
+      # @return [Response]
+      def create_topic
+        send_message(:post, :create_topic,
+          :params => {:topic => topic}
+        )
+      end
+
+      # Delete the topic
+      #
+      # @return [Response]
+      def delete_topic
+        send_message(:post, :delete_topic,
+          :params => {:topic => topic}
+        )
+      end
+
+      # Create channel on topic
+      #
+      # @param chan [String] channel name
+      # @return [Response]
+      def create_channel(chan)
+        send_message(:post, :create_channel,
+          :params => {
+            :topic => topic,
+            :channel => chan
+          }
+        )
+      end
+
+      # Delete channel on topic
+      #
+      # @param chan [String] channel name
+      # @return [Response]
+      def delete_channel(chan)
+        send_message(:post, :delete_channel,
+          :params => {
+            :topic => topic,
+            :channel => chan
+          }
+        )
+      end
+
+      # Remove all messages from topic
+      #
+      # @return [Response]
+      def empty_topic
+        send_message(:post, :empty_topic,
+          :params => {:topic => topic}
+        )
+      end
+
+      # Remove all messages from given channel on topic
+      #
+      # @param chan [String] channel name
+      # @return [Response]
+      def empty_channel(chan)
+        send_message(:post, :empty_channel,
+          :params => {
+            :topic => topic,
+            :channel => chan
+          }
+        )
+      end
+
+      # Pause messages on given channel
+      #
+      # @param chan [String] channel name
+      # @return [Response]
+      def pause_channel(chan)
+        send_message(:post, :pause_channel,
+          :params => {
+            :topic => topic,
+            :channel => chan
+          }
+        )
+      end
+
+      # Resume messages on a given channel
+      #
+      # @param chan [String] channel name
+      # @return [Response]
+      def unpause_channel(chan)
+        send_message(:post, :unpause_channel,
+          :params => {
+            :topic => topic,
+            :channel => chan
+          }
+        )
+      end
+
+      # Server stats
+      #
+      # @param format [String] format of data
+      # @return [Response]
+      def stats(format='json')
+        send_message(:get, :stats,
+          :params => {
+            :format => format
+          }
+        )
+      end
+
+      # Ping the server
+      #
+      # @return [Response]
+      def ping
+        send_message(:get, :ping)
+      end
+
+      # Server information
+      #
+      # @return [Response]
+      def info
+        send_message(:get, :info)
+      end
+
+    end
+  end
+end

data/lib/krakow/utils.rb

@@ -0,0 +1,9 @@
+require 'krakow'
+
+module Krakow
+  # Helper utilities
+  module Utils
+    autoload :Lazy, 'krakow/utils/lazy'
+    autoload :Logging, 'krakow/utils/logging'
+  end
+end

data/lib/krakow/utils/lazy.rb

@@ -0,0 +1,125 @@
+require 'krakow'
+
+module Krakow
+  module Utils
+    # Adds functionality to facilitate laziness
+    module Lazy
+
+      include Utils::Logging
+
+      # Instance methods for laziness
+      module InstanceMethods
+
+        # @return [Hash] argument hash
+        attr_reader :arguments
+
+        # Create new instance
+        #
+        # @param args [Hash]
+        # @return [Object]
+        def initialize(args={})
+          @arguments = {}.tap do |hash|
+            self.class.attributes.each do |name, options|
+              val = args[name]
+              if(options[:required] && !args.has_key?(name))
+                raise ArgumentError.new("Missing required option: `#{name}`")
+              end
+              if(val && options[:type] && !(valid = [options[:type]].flatten.compact).detect{|k| val.is_a?(k)})
+                raise TypeError.new("Invalid type for option `#{name}` (#{val} <#{val.class}>). Valid - #{valid.map(&:to_s).join(',')}")
+              end
+              if(val.nil? && options[:default] && !args.has_key?(name))
+                val = options[:default].respond_to?(:call) ? options[:default].call : options[:default]
+              end
+              hash[name] = val
+            end
+          end
+        end
+        alias_method :super_init, :initialize
+
+        # @return [String]
+        def to_s
+          "<#{self.class.name}:#{object_id}>"
+        end
+
+        # @return [String]
+        def inspect
+          "<#{self.class.name}:#{object_id} [#{arguments.inspect}]>"
+        end
+
+      end
+
+      # Class methods for laziness
+      module ClassMethods
+
+        # Add new attributes to class
+        #
+        # @param name [String]
+        # @param type [Class, Array<Class>]
+        # @param options [Hash]
+        # @option options [true, false] :required must be provided on initialization
+        # @option options [Object, Proc] :default default value
+        # @return [nil]
+        def attribute(name, type, options={})
+          name = name.to_sym
+          attributes[name] = {:type => type}.merge(options)
+          define_method(name) do
+            arguments[name.to_sym]
+          end
+          define_method("#{name}?") do
+            !!arguments[name.to_sym]
+          end
+          nil
+        end
+
+        # Return attributes
+        #
+        # @param args [Symbol] :required or :optional
+        # @return [Array<Hash>]
+        def attributes(*args)
+          @attributes ||= {}
+          if(args.include?(:required))
+            Hash[@attributes.find_all{|k,v| v[:required]}]
+          elsif(args.include?(:optional))
+            Hash[@attributes.find_all{|k,v| !v[:required]}]
+          else
+            @attributes
+          end
+        end
+
+        # Directly set attribute hash
+        #
+        # @param attrs [Hash]
+        # @return [TrueClass]
+        # @todo need deep dup here
+        def set_attributes(attrs)
+          @attributes = attrs.dup
+          true
+        end
+
+      end
+
+      class << self
+
+        # Injects laziness into class
+        #
+        # @param klass [Class]
+        def included(klass)
+          klass.class_eval do
+            include InstanceMethods
+            extend ClassMethods
+
+            class << self
+
+              def inherited(klass)
+                klass.set_attributes(self.attributes)
+              end
+
+            end
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/lib/krakow/utils/logging.rb

@@ -0,0 +1,43 @@
+require 'krakow'
+
+module Krakow
+  module Utils
+    # Logging helpers
+    module Logging
+
+      # Define base logging types
+      %w(debug info warn error).each do |key|
+        define_method(key) do |string|
+          log(key, string)
+        end
+      end
+
+      # Log message
+      #
+      # @param args [Array, nil]
+      # @return [Logger, nil]
+      def log(*args)
+        if(args.empty?)
+          Celluloid::Logger
+        else
+          severity, string = args
+          Celluloid::Logger.send(severity.to_sym, "#{self}: #{string}")
+          nil
+        end
+      end
+
+      class << self
+        # Set the logging output level
+        #
+        # @param level [Integer]
+        # @return [Integer, nil]
+        def level=(level)
+          if(Celluloid.logger.class == Logger)
+            Celluloid.logger.level = Logger.const_get(level.to_s.upcase.to_sym)
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/krakow/version.rb

@@ -0,0 +1,4 @@
+module Krakow
+  # Current version
+  VERSION = Gem::Version.new('0.1.0')
+end

metadata

@@ -0,0 +1,184 @@
+--- !ruby/object:Gem::Specification
+name: nsq-krakow
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Chris Roberts
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-06-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: celluloid
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.16.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.16.0
+- !ruby/object:Gem::Dependency
+  name: http
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: multi_json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: digest-crc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: childprocess
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: snappy
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: NSQ ruby library
+email: code@chrisroberts.org
+executables: []
+extensions: []
+extra_rdoc_files:
+- CHANGELOG.md
+- CONTRIBUTING.md
+- LICENSE
+files:
+- CHANGELOG.md
+- CONTRIBUTING.md
+- LICENSE
+- README.md
+- krakow.gemspec
+- lib/krakow.rb
+- lib/krakow/command.rb
+- lib/krakow/command/auth.rb
+- lib/krakow/command/cls.rb
+- lib/krakow/command/fin.rb
+- lib/krakow/command/identify.rb
+- lib/krakow/command/mpub.rb
+- lib/krakow/command/nop.rb
+- lib/krakow/command/pub.rb
+- lib/krakow/command/rdy.rb
+- lib/krakow/command/req.rb
+- lib/krakow/command/sub.rb
+- lib/krakow/command/touch.rb
+- lib/krakow/connection.rb
+- lib/krakow/connection_features.rb
+- lib/krakow/connection_features/deflate.rb
+- lib/krakow/connection_features/snappy_frames.rb
+- lib/krakow/connection_features/ssl.rb
+- lib/krakow/consumer.rb
+- lib/krakow/consumer/queue.rb
+- lib/krakow/discovery.rb
+- lib/krakow/distribution.rb
+- lib/krakow/distribution/default.rb
+- lib/krakow/exceptions.rb
+- lib/krakow/frame_type.rb
+- lib/krakow/frame_type/error.rb
+- lib/krakow/frame_type/message.rb
+- lib/krakow/frame_type/response.rb
+- lib/krakow/ksocket.rb
+- lib/krakow/producer.rb
+- lib/krakow/producer/http.rb
+- lib/krakow/utils.rb
+- lib/krakow/utils/lazy.rb
+- lib/krakow/utils/logging.rb
+- lib/krakow/version.rb
+homepage: http://github.com/chrisroberts/krakow
+licenses:
+- Apache 2.0
+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.5.1
+signing_key: 
+specification_version: 4
+summary: NSQ library
+test_files: []