pubnub-publisher 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ea389b2bbe81e52d0c3789f85d8f3f6acce213bc
+  data.tar.gz: dd0a6ef4720d420f44748ec81ee78873c5e81399
+SHA512:
+  metadata.gz: 683fe19193c0d1b374415cb6e2c119f6fd58d9fda28f054c89b73231852219bb495919265a2e048d8a3d33e8d7b48310b6c2db611952caea9e05fc3222d9740f
+  data.tar.gz: 66f62daa6f402c9e0065fa30c8b9103446aa560813dc05cae72ff740db222d35818d467b97641abeab24579fc6866ea9bd98d86d4db9b0d8edf0663f2dd8e272

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in pubnub-publisher.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Matt Aimonetti
+
+MIT License
+
+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/README.md

@@ -0,0 +1,127 @@
+# Pubnub::Publisher
+
+This gem is a addon for the official [PubNub's Ruby
+gem](https://github.com/pubnub/ruby). Unlike the official gem, this
+doesn't have any dependencies, it relies entirely on Ruby's stdlib.
+
+But unlike the official gem, this gem only provides one pub sub feature:
+publication.
+
+Use this library when your Ruby application only publishes events to
+PubNub. For instance you might have a Go/Scala/Node.js app and many JS
+clients listening on a few channels. But you need to broadcast a
+message and want to do that after a trigger in your Rails app.
+The cleanest way to do that is to use this gem to simply publish the
+message and disconnect. This is done via PubNub's REST API.
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'pubnub-publisher'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install pubnub-publisher
+
+## Usage
+
+Look at the test suite in the spec folder for more details.
+The easiest way to use this library is to register a shared config at
+the class level:
+
+```ruby
+Pubnub::Publisher.setup(publish_key: "your pub key", subscribe_key: "your sub key")
+```
+
+Note: I don't quite understand why Pubnub requires a subscribe key to
+publish but you need to provide it otherwise the API call will fail.
+
+You can set the following shared config keys:
+
+* publish_key
+* subscribe_key
+* secret_key
+* cipher_key
+* origin (defaults to "pubsub.pubnub.com")
+* ssl (defaults to true)
+* session_uuid (randomly generated if you don't provide one)
+
+Once you have the shared config setup, you can create an instance which
+will use the default config unless instructed differently:
+
+```ruby
+pub_client = Pubnub::Publisher.new
+```
+
+You can override any of the shared config an instantiation or by using
+the accessors:
+
+```ruby
+pub_client = Pubnub::Publisher.new(publish_key: "demo_pub_key", subscribe_key: "demo_sub_key", origin: "demo.pubnub.com")
+```
+
+or 
+
+```ruby
+pub_client = Pubnub::Publisher.new
+pub_client.session_uuid = "ruby-app"
+```
+
+To publish a message, you call the `#publish` method passing the
+channel name and a data structure that will be passed as a json.
+
+```ruby
+pub_client = Pubnub::Publisher.new
+pub_client.publish("test", {text: "Hi there, this is Matt"})
+```
+
+The publication is currently blocking and will return a boolean value
+so you can handle retries on your own.
+Eventually, publication might have an option to happen via a thread pool
+and callbacks. I would also like to persist the http connection to
+improve performance.
+
+```ruby
+if pub_client.publish("test", {text: "Hi there, this is Matt"})
+  Rails.logger.info "The Pubnub publishing was successful sir!"
+else 
+  Rails.logger.error "Something went bad with PubNub :( #wasntme"
+end
+```
+
+## TODOs
+
+* Use a thread pool to go non blocking publishing.
+* use a persistent http connection to pubnub.
+
+
+## Test suite
+
+The test suite is a simple Rspec test suite, with 1 specificity: the
+"integration" tag. By default, when you run the specs, the test suite
+will connect to PubNub to verify that things work well. You can turn
+off the integration specs by excluding them:
+
+```
+$ rspec . --tag ~integration
+```
+
+To run the full test suite:
+
+```
+$ rake
+```
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,8 @@
+require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.rspec_opts = "--format documentation"
+end
+
+task :default => :spec

data/lib/pubnub/publisher.rb

@@ -0,0 +1,116 @@
+require "pubnub/publisher/version"
+
+module Pubnub
+  class Publisher
+
+    CONFIG_KEYS = [:publish_key, :subscribe_key, :secret_key, :cipher_key, :ssl, :origin, :session_uuid]
+    REQUIRED_KEYS = [:publish_key, :subscribe_key, :origin]
+    DEFAULT_ORIGIN = "pubsub.pubnub.com"
+    attr_accessor *CONFIG_KEYS
+
+    class ConfigNotSet < StandardError; end
+
+    # sets up the class so instances can inherit from the default config.
+    #
+    # @param opts [hash] keyed by symbols, stores the connection config that is 
+    # then used by default by all instances.
+    def self.setup(opts={})
+      @publish_key = opts[:publish_key] if opts[:publish_key]
+      @subscribe_key = opts[:subscribe_key] if opts[:subscribe_key]
+      @secret_key = opts[:secret_key] if opts[:secret_key]
+      @cipher_key = opts[:cipher_key] if opts[:cipher_key]
+      @origin = opts[:origin] || DEFAULT_ORIGIN
+      @session_uuid = opts[:session_uuid] || SecureRandom.uuid
+      @ssl = opts[:ssl].nil? ? true : opts[:ssl]
+    end
+
+    # resets the shared config
+    def self.clear
+      @publish_key, @subscribe_key, @secret_key, @cipher_key, @origin, @session_uuid, @ssl = nil, nil, nil, nil, "pubsub.pubnub.com", nil, true
+    end
+
+    def self.set_default_values(instance)
+      instance.publish_key ||= @publish_key if @publish_key
+      instance.subscribe_key ||= @subscribe_key if @subscribe_key
+      instance.secret_key ||= @secret_key if @secret_key
+      instance.cipher_key ||= @cipher_key if @cipher_key
+      instance.origin ||= (@origin || DEFAULT_ORIGIN)
+      instance.session_uuid ||= (@session_uuid || SecureRandom.uuid)
+      if instance.ssl.nil?
+        instance.ssl = !@ssl.nil? ? @ssl : true
+      end
+      instance
+    end
+
+    def initialize(opts={})
+      opts.each do |k,v|
+        next unless CONFIG_KEYS.include?(k)
+        self.send("#{k}=", v)
+      end
+      # load the default values
+      self.class.set_default_values(self)
+      self
+    end
+
+    def publish(channel, message)
+      check_config
+      http, request = prepare_message_publishing(channel, message)
+      response = http.request(request)
+      if response.code == "200"
+        # check response
+        # [1 good!
+        # [0 bad!
+        if response.body =~ /\[1,/
+          true
+        else
+          $stderr << response.body[/\[\d,"(.*)"/]
+          false
+        end
+      else
+        $stderr << response.inspect
+        false
+      end
+    end
+
+    def check_config
+      if @config_ok
+        true
+      else
+        REQUIRED_KEYS.each do |k|
+          value = self.send(k)
+          raise ConfigNotSet.new("#{k} not set") if value.nil? || value == ""
+        end
+        @config_ok = true
+      end
+    end
+
+    #http://pubsub.pubnub.com
+    # /publish
+    # /pub-key
+    # /sub-key
+    # /signature
+    # /channel
+    # /callback
+    def publish_url(channel)
+      (ssl ? "https" : "http") << "://#{origin}/publish/#{publish_key}/#{subscribe_key}/#{secret_key || 0}/#{channel}/0"
+    end
+
+    def prepare_message_publishing(channel, message)
+      raise ArgumentError if (channel.nil? || channel == "" || message.nil? || message == "")
+
+      # prepare a GET request (come on pubnub, GET???)
+      url =  publish_url(channel) << "/#{URI.escape(message.to_json)}"
+      uri = URI.parse(url)
+      http = Net::HTTP.new(uri.host, uri.port)
+
+      # gonna have to deal with certs
+      if ssl
+        http.use_ssl = true
+        http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+      end
+      request = Net::HTTP::Get.new(uri.request_uri)
+      return http, request
+    end
+
+  end
+end

data/lib/pubnub/publisher/version.rb

@@ -0,0 +1,12 @@
+require "base64"
+require "net/https"
+require "net/http"
+require "uri"
+require "json"
+require "securerandom"
+
+module Pubnub
+  class Publisher
+    VERSION = "1.0.0"
+  end
+end

data/pubnub-publisher.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'pubnub/publisher/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "pubnub-publisher"
+  spec.version       = Pubnub::Publisher::VERSION
+  spec.authors       = ["Matt Aimonetti"]
+  spec.email         = ["mattaimonetti@gmail.com"]
+  spec.description   = %q{The simplest PubNub gem possible to simply publish events. Nothing more.}
+  spec.summary       = %q{Because when you only care to publish events, you don't want to load a bunch of unneeded dependencies.}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+end

data/spec/publisher_spec.rb

@@ -0,0 +1,135 @@
+require 'spec_helper'
+
+describe Pubnub::Publisher do
+  context "Class setup" do
+
+    it "has default values" do
+      pub_client = Pubnub::Publisher.new
+      expect(pub_client.publish_key).to be_nil
+      expect(pub_client.subscribe_key).to be_nil
+      expect(pub_client.secret_key).to be_nil
+      expect(pub_client.cipher_key).to be_nil
+      expect(pub_client.origin).to eq("pubsub.pubnub.com")
+      expect(pub_client.session_uuid).to_not be_empty
+      expect(pub_client.ssl).to be_true
+    end
+
+    it "allows a dev to set some shared config options" do
+      Pubnub::Publisher.setup(publish_key: "test pub key")
+      pub_client = Pubnub::Publisher.new
+      expect(pub_client.publish_key).to eq("test pub key")
+
+      Pubnub::Publisher.setup(subscribe_key: "test sub key")
+      pub_client = Pubnub::Publisher.new
+      expect(pub_client.subscribe_key).to eq("test sub key")
+
+      Pubnub::Publisher.setup(secret_key: "test secret key")
+      pub_client = Pubnub::Publisher.new
+      expect(pub_client.secret_key).to eq("test secret key")
+
+      Pubnub::Publisher.setup(cipher_key: "test cipher key")
+      pub_client = Pubnub::Publisher.new
+      expect(pub_client.cipher_key).to eq("test cipher key")
+
+      Pubnub::Publisher.setup(origin: "matt.pubnub.com")
+      pub_client = Pubnub::Publisher.new
+      expect(pub_client.origin).to eq("matt.pubnub.com")
+
+      Pubnub::Publisher.setup(session_uuid: "test-runner")
+      pub_client = Pubnub::Publisher.new
+      expect(pub_client.session_uuid).to eq("test-runner")
+
+      Pubnub::Publisher.setup(ssl: false)
+      pub_client = Pubnub::Publisher.new
+      expect(pub_client.ssl).to be_false
+    end
+
+    it "can be cleared" do
+      Pubnub::Publisher.clear
+      pub_client = Pubnub::Publisher.new
+      expect(pub_client.publish_key).to be_nil
+      expect(pub_client.subscribe_key).to be_nil
+      expect(pub_client.secret_key).to be_nil
+      expect(pub_client.cipher_key).to be_nil
+      expect(pub_client.origin).to eq("pubsub.pubnub.com")
+      expect(pub_client.session_uuid).to_not be_empty
+      expect(pub_client.ssl).to be_true
+    end
+
+  end
+
+  context "new instance" do
+    before :each do
+      Pubnub::Publisher.clear
+    end
+
+    it "can have custom config values" do
+      pub_client = Pubnub::Publisher.new(publish_key: "test pub key")
+      expect(pub_client.publish_key).to eq("test pub key")
+
+      pub_client = Pubnub::Publisher.new(subscribe_key: "test sub key")
+      expect(pub_client.subscribe_key).to eq("test sub key")
+
+      pub_client = Pubnub::Publisher.new(secret_key: "test secret key")
+      expect(pub_client.secret_key).to eq("test secret key")
+
+      pub_client = Pubnub::Publisher.new(cipher_key: "test cipher key")
+      expect(pub_client.cipher_key).to eq("test cipher key")
+
+      pub_client = Pubnub::Publisher.new(origin: "matt.pubnub.com")
+      expect(pub_client.origin).to eq("matt.pubnub.com")
+
+      pub_client = Pubnub::Publisher.new(session_uuid: "test-instance-runner")
+      expect(pub_client.session_uuid).to eq("test-instance-runner")
+
+      pub_client = Pubnub::Publisher.new(ssl: false)
+      expect(pub_client.ssl).to be_false
+    end
+
+    it "can be verified (check that required fields are set)" do
+      pub_client = Pubnub::Publisher.new
+      expect(pub_client.publish_key).to be_nil
+      expect{ pub_client.check_config }.to raise_error(Pubnub::Publisher::ConfigNotSet)
+
+      valid_config = {publish_key: "test", subscribe_key: "test", origin: "test.pubnub.com"}
+      expect{ Pubnub::Publisher.new(valid_config).check_config }.to_not raise_error(Pubnub::Publisher::ConfigNotSet)
+      without_pub_key = valid_config.dup
+      without_pub_key.delete(:publish_key)
+      expect{ Pubnub::Publisher.new(without_pub_key).check_config }.to raise_error(Pubnub::Publisher::ConfigNotSet)
+      without_sub_key = valid_config.dup
+      without_sub_key.delete(:subscribe_key)
+      expect{ Pubnub::Publisher.new(without_sub_key).check_config }.to raise_error(Pubnub::Publisher::ConfigNotSet)
+      without_origin = valid_config.dup
+      without_origin[:origin] = ""
+      expect{ Pubnub::Publisher.new(without_origin).check_config }.to raise_error(Pubnub::Publisher::ConfigNotSet)
+    end
+
+    it "has a publish url for a given channel" do
+      pub_client = Pubnub::Publisher.new(publish_key: "demo_pub_key", subscribe_key: "demo_sub_key", origin: "demo.pubnub.com")
+      expect(pub_client.publish_url("mychannel")).to eq("https://demo.pubnub.com/publish/demo_pub_key/demo_sub_key/0/mychannel/0")
+    end
+
+    it "can prepare a http request to publish a message" do
+      pub_client = Pubnub::Publisher.new(publish_key: "demo_pub_key", subscribe_key: "demo_sub_key", origin: "demo.pubnub.com")
+      http, request = pub_client.prepare_message_publishing("mychannel", {text: "hey"})
+      expect(http.address).to eq("demo.pubnub.com")
+      expect(http.use_ssl?).to be_true
+      expect(http.port).to eq(443)
+      expect(request.path).to eq("/publish/demo_pub_key/demo_sub_key/0/mychannel/0/%7B%22text%22:%22hey%22%7D")
+      expect(request).to be_instance_of(Net::HTTP::Get)
+    end
+
+    it "successfully publishes messages", integration: true do
+      pub_client = Pubnub::Publisher.new(publish_key: "demo", subscribe_key: "demo")
+      output = pub_client.publish("test", {text: "test from PubNub Publisher's Ruby gem"})
+      expect(output).to be_true
+    end
+
+    it "handles messages which failed to publish", integration: true do
+      pub_client = Pubnub::Publisher.new(publish_key: "bad-demo", subscribe_key: "demo")
+      output = pub_client.publish("test", {text: "test from PubNub Publisher's Ruby gem"})
+      expect(output).to be_false
+    end
+
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,2 @@
+require_relative "../lib/pubnub/publisher"
+require 'rspec/autorun'

metadata

@@ -0,0 +1,99 @@
+--- !ruby/object:Gem::Specification
+name: pubnub-publisher
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Matt Aimonetti
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-07-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  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: rspec
+  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: The simplest PubNub gem possible to simply publish events. Nothing more.
+email:
+- mattaimonetti@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/pubnub/publisher.rb
+- lib/pubnub/publisher/version.rb
+- pubnub-publisher.gemspec
+- spec/publisher_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+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.0.3
+signing_key: 
+specification_version: 4
+summary: Because when you only care to publish events, you don't want to load a bunch
+  of unneeded dependencies.
+test_files:
+- spec/publisher_spec.rb
+- spec/spec_helper.rb