centrifuge 0.1.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5c72f7e53d98f1c39fa274dad8db771151df6275
-  data.tar.gz: c26967230df365720bcab949250650cd1f368df5
+  metadata.gz: 3d24a6b2607907f90eee9fc465ecf5fc59e231c3
+  data.tar.gz: 49908552ac245cbbb3b3d5c773e5b5df35b89e3f
 SHA512:
-  metadata.gz: 753fe93461f18f82a268cb0e648e30bb0cce09f88aace6d5b15a044eef1e291d1b1105f57adaccc462d48e4647a6a932aa436717a450e2e8c14fb3e23c2dc8c6
-  data.tar.gz: 9af78670d1570d93fabc973ff7e46c3e254560e77864d253dc9bfb9a2128c0cf30d1cca2261aa0b46b4bcc95f2bba4da658bae438ea4825adad333e9e9c3e27f
+  metadata.gz: f5943232807ff2c1dd6329dacf65ae812a110096005c1118713e3138fcd6856253750a73cab5677262fe94cda537ae517d7bc5d8cca12c4e171b737b0206ef94
+  data.tar.gz: 3d4787d2ddff2d82c787dd539648aad42922f27338646d935175ca5e6c59715e27f38a75b3845480dd3befeaa124378f51962db5508c61ba63cb1dff49468290

data/README.md

@@ -8,8 +8,8 @@ Ruby gem for [Centrifuge](https://github.com/centrifugal/centrifuge) real-time m
 
 Add this line to your application's Gemfile:
 
-```
-gem 'centrifuge'
+```ruby
+	gem 'centrifuge'
 ```
 
 And then execute:
@@ -20,39 +20,51 @@ Or install it yourself as:
 
     $ gem install centrifuge
 
-Compatible version for Centrifuge version 0.8.0 and above are 0.1.0+. Please use 0.0.x versions for older Centrifuge
+## Compatibility
+
+Centrifuge-ruby 1.0.0+ supports only Centrifuge version 1.0.0+ with single project only.
+If you want to use multiproject Centrifuge, please use centrifuge-ruby 0.1.0
 
 ## Usage
 
 `Centrifuge::Client` - is main usable class. Start with:
 
-	client = Centrifute::Client.new(scheme: :http, host: :localhost, port: 80, project_key: 'abc', secret: 'cde')
+```ruby
+	client = Centrifuge::Client.new(scheme: :http, host: :localhost, port: 80, secret: 'cde')
+```
 
-If you are planning to use only one project, its convenient to set all data and use class methods:
+Or just:
 
+```ruby
 	Centrifuge.scheme = :http
 	Centrifuge.host = 'localhost'
 	Centrifuge.port = 8000
-	Centrifuge.project_key = 'abc'
 	Centrifuge.secret = 'def'
+```
 
-There are five methds available:
+There are six methods available:
 
 ### Publish
 
 Sends message to all connected users:
 
+```ruby
 	client.publish('teshchannel', { data: :foo })
+```
 
 You can also use class methods if you set all necessary config data:
 
+```ruby
 	Centrifuge.publish('testchannel', { data: :foo })
+```
 
 ### Unsubscribe
 
 Unsubscribes user from channel:
 
+```ruby
 	client.unsubscribe('testchannel', 'user#23')
+```
 
 `user#23` - is string identificator of user.
 
@@ -60,29 +72,149 @@ Unsubscribes user from channel:
 
 Disconnects user from Centrifuge:
 
+```ruby
 	client.disconnect('user#23')
-
+```
 ### Presence
 
 Gets presence info of the channel:
 
+```ruby
 	client.presence('testchannel')
-
+```
 ### History
 
 Gets message history of the channel:
 
+```ruby
 	client.history('test_channel')
+```
+
+### Channels
+
+Get active channels (with one or more subscribers):
+
+```ruby
+	client.channels()
+```
 
 ### JS Client token generation
 
 Generates token for JS client:
 
-	client.token_for('testuser', '123123')
+```ruby
+	client.token_for('testuser', '1443422448')
+```
+Where `1443422448` is UNIX timestamp seconds. You can also add user info as valid json string as third parameter:
+
+```ruby
+	client.token_for('testuser', '1443422448', "{}")
+```
+### Channel Sign token generation
+
+Generates Sign token for a Channel:
+
+```ruby
+client.generate_channel_sign(params[:client], params[:channels], "{}")
+```
+
+Where ```params[:client]``` is client passed during authentication and ```params[:channels]``` can be an array of channels or a single channel. You can read more here about batching channels here [JS Documentation](https://fzambia.gitbooks.io/centrifugal/content/client/api.html).
+
+You can also add user info as valid json string as third parameter:
+
+```ruby
+client.generate_channel_sign(params[:client], params[:channels], "{"name": "John"}")
+```
+
+On server side using rails, you can authenticate private channels like so:
+
+```ruby
+
+	#routes.rb or any router lib
+	post 'sockets/auth'
+
+	# Auth method to authenticate private channels
+	#sockets_controller.rb or anywhere in your app
+
+	# client = Instance of Centrifuge initialized // check Usage section
+	# params[:channels] = single/array of channels
+	def auth
+	  if user_signed_in? # Or use a before_filter
+	    data = {}
+	    sign = client.generate_channel_sign(
+	        params[:client], params[:channels], "{}"
+	    )
+	    data[channel] = {
+	        "sign": sign,
+	        "info": "{}"
+	    }
+	    render :json => data
+	  else
+	    render :text => "Not authorized", :status => '403'
+	  end
+	end
+```
+On client side initialize Centrifuge like so:
+
+``` javascript
+
+	// client_info = valid JSON string of user_info
+	// client_token = client.token_for (described above)
+
+	var centrifuge = new Centrifuge({
+	   url: "http://localhost:8000/connection",
+	   user: window.currentUser.id,
+	   timestamp: window.currentUser.current_timestamp,
+	   debug: true,
+	   info: JSON.stringify(window.client_info),
+	   token: window.client_token,
+	   refreshEndpoint: "/sockets/refresh",
+	   authEndpoint: "/sockets/auth",
+	   authHeaders: {
+	      'X-Transaction': 'WebSocket Auth',
+	      'X-CSRF-Token': window.currentUser.form_authenticity_token
+	   },
+	   refreshHeaders: {
+	      'X-Transaction': 'WebSocket Auth',
+	      'X-CSRF-Token': window.currentUser.form_authenticity_token
+	   }
+	 });
+
+	centrifuge.connect();
+
+	// If you using jbuiler use raw render(template_name) and use a global window object to load the user information.
+```
+
+If you want to batch sign channels request to avoid multiple HTTP requests, you can use centrifuge JS client to batch channels ```centrifuge.startBatching(); // your code // centrifuge.stopBatching();``` in one request and on the server iterate through channels and subscribe.
+
+Read more: [JS client Documentation](https://fzambia.gitbooks.io/centrifugal/content/client/api.html)
+
+### API request sign
+
+When you use Centrifugo server API you should sign each request to successfully authorize with the server.
+
+```ruby
+
+	# For example this is how you would encode a Publish command
+	commands = {
+		"method": "publish",
+	  	"params": {
+			"channel": "Test",
+		  	"data": { "name": "John Doe" }
+	  	}
+	}
+
+	encoded_data = MultiJson.dump(commands) # Or use to_json
+	sign = client.sign(encoded_data) #Sign the data
+
+	# Using HTTP party GEM interact with Server API
+	r = HTTParty.post(client.url.to_s, query: {"sign": sign, "data": encoded_data})
+	r.parsed_response
+
+```
 
-Where `123123` is UNIX timestamp. You can also add user info as valid json string as third parameter:
+```encoded_data``` is a JSON string with your API command/commands. See all available commands in [Server API](https://fzambia.gitbooks.io/centrifugal/content/server/api.html) chapter.
 
-	client.token_for('testuser', '123123', "{}")
 
 ## Rails assets
 

data/lib/centrifuge/client.rb

@@ -9,7 +9,7 @@ module Centrifuge
       host: 'localhost',
       port: 8000,
     }
-    attr_accessor :scheme, :host, :port, :project_key, :secret
+    attr_accessor :scheme, :host, :port, :secret
     attr_writer :connect_timeout, :send_timeout, :receive_timeout,
     :keep_alive_timeout
 
@@ -17,8 +17,8 @@ module Centrifuge
 
     def initialize(options = {})
       options = DEFAULT_OPTIONS.merge(options)
-      @scheme, @host, @port, @project_key, @secret = options.values_at(
-       :scheme, :host, :port, :project_key, :secret
+      @scheme, @host, @port, @secret = options.values_at(
+       :scheme, :host, :port, :secret
       )
       set_default_timeouts
     end
@@ -35,7 +35,7 @@ module Centrifuge
         scheme: scheme.to_s,
         host: host,
         port: port,
-        path: "/api/#{project_key}#{path}"
+        path: "/api/#{path}"
       })
     end
 
@@ -59,13 +59,25 @@ module Centrifuge
       Centrifuge::Builder.new('history', { channel: channel }, self).process
     end
 
+    def channels()
+      Centrifuge::Builder.new('channels', {}, self).process
+    end
+
+    def stats()
+      Centrifuge::Builder.new('stats', {}, self).process
+    end
+
     def token_for(user, timestamp, user_info = "")
       sign("#{user}#{timestamp}#{user_info}")
     end
 
+    def generate_channel_sign(client, channel, user_info="")
+      data = "#{client}#{channel}#{user_info}"
+      OpenSSL::HMAC.hexdigest(OpenSSL::Digest::SHA256.new, secret, data)
+    end
+
     def sign(body)
-      dig = OpenSSL::Digest.new('sha256')
-      OpenSSL::HMAC.hexdigest(dig, secret, "#{project_key}#{body}")
+      OpenSSL::HMAC.hexdigest(OpenSSL::Digest::SHA256.new, secret, body)
     end
 
     def client
@@ -78,5 +90,6 @@ module Centrifuge
         end
       end
     end
+
   end
 end

data/lib/centrifuge/version.rb

@@ -1,3 +1,3 @@
 module Centrifuge
-  VERSION = "0.1.0"
+  VERSION = "1.0.0"
 end

data/lib/centrifuge.rb

@@ -16,8 +16,8 @@ module Centrifuge
   class << self
     extend Forwardable
 
-    def_delegators :default_client, :scheme, :host, :port, :project_key, :secret
-    def_delegators :default_client, :scheme=, :host=, :port=, :project_key=, :secret=
+    def_delegators :default_client, :scheme, :host, :port, :secret
+    def_delegators :default_client, :scheme=, :host=, :port=, :secret=
 
     # def_delegators :default_client, :authentication_token, :url
     # def_delegators :default_client, :encrypted=, :url=

data/spec/client_spec.rb

@@ -1,12 +1,12 @@
 require 'spec_helper'
 
 describe Centrifuge::Client do
-  let(:options) { { scheme: :https, host: 'centrifugo.herokuapp.com', port: 443, project_key: 'development', secret: 'secret' } }
+  let(:options) { { scheme: :https, host: 'centrifugo-dev.herokuapp.com', port: 443, secret: 'secret' } }
   let(:client) { Centrifuge::Client.new(options) }
   let(:data) { { action: :test } }
 
   it 'generates url' do
-    expect(client.url.to_s).to eq "https://centrifugo.herokuapp.com:443/api/#{client.project_key}"
+    expect(client.url.to_s).to eq "https://centrifugo-dev.herokuapp.com:443/api/"
   end
 
   it 'publishes data' do