philote 0.1.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d557198f8bbe6a2c9e3dbdbbe09883bd10823ef0
-  data.tar.gz: 72e9eb3d90d5f08b330a8cfe135d2d4a6a22a05b
+  metadata.gz: 83d0f685634d24a1933c7b4f1b24f8f2522b75de
+  data.tar.gz: b35d3bbfa5239de1afdf3494ba7568fa8be9fadf
 SHA512:
-  metadata.gz: 1f8e06dc95017cf9d64340e5e893e972a378434ea4ba477019b4ff12d8bf97e4605cf3b007a992d6ca379104d6521984a79aed70ab172fbee80889f4c79bf322
-  data.tar.gz: cdd9c5a0156dd88c5912fa777bd0d0d0804c6191c91a8bc977d725e148df5505b8ef835b69ccbad933b35e175c3655b9d9d1df11d3b2694ed6d0db4c26f836b5
+  metadata.gz: 981e71e46ee073dea63e67f1d5d0dca72ef3afcd8c46a1ca08561ecf426f1ea59be43c12bf9ef193195b282892082b72fba8e88a8b5eb0189b499e90e83d7d47
+  data.tar.gz: 2a0dd3137c8da5ea54e9331350deaa8701bd3ab25ea8f030dff9b9857dd3a19d04c8e6f7af18a29627c83d179dbe7b168366fa3166f0f9bdb918b811c9748b87

data/.env.sample

@@ -1,7 +1,7 @@
 # vim: ft=sh
-export GEM_HOME="$PWD/.deps"
+export GEM_HOME="$PWD/.dependencies"
 export GEM_BIN="$GEM_HOME/bin"
+export RUBYLIB="$PWD/lib":"$RUBYLIB"
 export PATH="$GEM_BIN":"$PATH"
 
-export DISC_CONCURRENCY=2
-export QUEUES="test_medium"
+export REDIS_TEST_URL="redis://localhost:6379/9"

data/.gems

@@ -1,2 +1,3 @@
 cutest:1.2.2
 redic:1.5.0
+byebug:9.0.5

data/.gitignore

@@ -1,3 +1,2 @@
 *.gem
-nodes.conf
-.deps
+.dependencies

data/README.md

@@ -0,0 +1,73 @@
+# philote.rb
+
+This is a helper library for [Philote](https://github.com/13Floor/philote), a [Redis](http://redis.io)-powered websockets server.
+
+You don't really need this library: philote takes configuration from the Redis database it uses, so you are perfectly capable of create philote access tokens yourself and storing them in redis, however, this library makes it easier for you to do so.
+
+## Early Stages
+
+This library is still on very early stages, it does something extremely simple so bugs are generally not expected, but functionality like subscribing to channels and reacting to incoming messages is not yet implemented, if you use Philote for anything and feel like contributing that would be a great way to do it. :)
+
+
+## Usage
+
+### Redis Connection
+
+By default, Philote connects to Redis using the `REDIS_URL` environment variable, if you want to connect in a different way you can specify the redis client in code when you initialize your application.
+
+```ruby
+
+require 'redic'
+require 'philote'
+
+Philote.redis = Redic.new('redis://localhost:6379')
+```
+
+### Access Keys
+
+In order to connect to Philote, a websocket client will need an [access key](https://github.com/pote/philote#access-keys), you can create them via `Philote::AccessKey#create`, here's the method signature:
+
+```ruby
+class AccessKey
+    # read:
+    #   an array of channel names the key user will be subscribed to.
+    #
+    # write:
+    #   an array of channel names the key user will be able to write to.
+    #
+    # allowed_uses:
+    #   the ammount of times a new websocket client will be able to authenticate
+    #   using this access key.
+    #
+    # uses:
+    #   the ammount of times a new websocket client has authenticated using this
+    #   access key.
+    #
+    # token:
+    #   the redis identifier.
+    #
+    def initialize(read: [], write: [], allowed_uses: 1, uses: 0, token: nil)
+      # ...
+    end
+end
+```
+
+After you create an access key, a client will be able to authenticate in the Philote server running on the same Redis instance, `Philote::AccessKey#token` will contain the identifier, on a regular browser javascript use case you'll render your view with access to this token.
+
+### Publishing Messages
+
+As Philote uses Redis PUB/SUB under the hood, as long as your Ruby code has access to the same Redis instance you can publish messages to the websocket channels simply by publishing those messages to Redis, this library provides a helper method to do that.
+
+```ruby
+Philote.publish('channel-name', 'data')
+```
+
+## Run the test suite
+
+Here's how to set up the local/test environment:
+
+```bash
+$ git clone git@github.com:pote/philote-rb.git && cd philote-rb
+$ source .env.sample # Make sure to review the settings, as the REDIS_TEST_URL gets flushed when running the test suite.
+$ make test
+```

data/lib/philote.rb

@@ -7,10 +7,118 @@ module Philote
     @redis ||= Redic.new
   end
 
-  def self.redis=(redis)
-    @redis = redis
+  def self.redis=(client)
+    @redis = client
   end
+
+  def self.prefix
+    @prefix ||= 'philote'
+  end
+
+  def self.prefix=(p)
+    @prefix = p
+  end
+
+  def self.publish(channel, data)
+    redis.call('PUBLISH', channel, data)
+  end
+
+  class AccessKey
+    attr_accessor :read, :write, :allowed_uses, :uses, :token
+
+
+    # read:
+    #   an array of channel names the key user will be subscribed to.
+    #
+    # write:
+    #   an array of channel names the key user will be able to write to.
+    #
+    # allowed_uses:
+    #   the ammount of times a new websocket client will be able to authenticate
+    #   using this access key.
+    #
+    # uses:
+    #   the ammount of times a new websocket client has authenticated using this
+    #   access key.
+    #
+    # token:
+    #   the redis identifier.
+    #
+    def initialize(read: [], write: [], allowed_uses: 1, uses: 0, token: nil)
+      @token = token || SecureRandom.urlsafe_base64
+      @read = read
+      @write = write
+      @allowed_uses = allowed_uses
+      @uses = uses
+
+      self
+    end
+
+    def to_json
+      self.to_h.to_json
+    end
+
+    def save
+      Philote.redis.call('SET', "#{ Philote.prefix }:access_key:#{ token }", self.to_json)
+    end
+
+    def to_h
+      {
+        read: read,
+        write: write,
+        allowed_uses: allowed_uses,
+        uses: uses
+      }
+    end
+    alias_method :to_hash, :to_h
+
+
+    def self.create(**args)
+      key = self.new(**args)
+      key.save
+
+      return key
+    end
+
+    def self.load!(token)
+      raw_key = Philote.redis.call('GET', "philote:access_key:#{ token }")
+      raise NonExistantAccessKey if raw_key.nil?
+
+      begin
+        parsed_key_attributes = JSON.parse(raw_key)
+      rescue => exception
+        raise UnparsableAccessKeyData.new(exception)
+      end
+
+      begin
+        key_attributes = {
+          read: parsed_key_attributes.fetch('read'),
+          write: parsed_key_attributes.fetch('write'),
+          allowed_uses: parsed_key_attributes.fetch('allowed_uses'),
+          uses: parsed_key_attributes.fetch('uses'),
+          token: token
+        }
+      rescue => exception
+        raise InsufficientAccessKeyData.new(exception)
+      end
+
+      return self.new(key_attributes)
+    end
+
+    def self.load(token)
+      begin
+        key = self.load!(token)
+        return key
+      rescue => exception
+        return nil
+      end
+    end
+  end
+
+  class Error < StandardError; end
+  class NonExistantAccessKey < Error; end
+  class UnparsableAccessKeyData < Error; end
+  class InsufficientAccessKeyData < Error; end
 end
 
 require_relative 'philote/version'
-require_relative 'philote/admin'

data/lib/philote/version.rb

@@ -1,3 +1,3 @@
 module Philote
-  VERSION = "0.1.0"
+  VERSION = "0.3.0"
 end

data/test/access_key_test.rb

@@ -0,0 +1,45 @@
+require 'cutest'
+require 'philote'
+
+
+setup {
+  Philote.redis = Redic.new(ENV.fetch('REDIS_TEST_URL'))
+}
+
+at_exit {
+  Redic.new(ENV.fetch('REDIS_TEST_URL')).call('FLUSHDB')
+}
+
+test 'client should have a functioning redis connection' do
+  assert_equal 'PONG', Philote.redis.call('PING')
+end
+
+test 'creating an access key creates a token with sensible defaults' do
+  access_key = Philote::AccessKey.create
+
+  assert_equal [], access_key.read
+  assert_equal [], access_key.write
+  assert_equal 1, access_key.allowed_uses
+  assert_equal 0, access_key.uses
+  assert !access_key.token.nil?
+end
+
+test 'loading an access key works' do
+  access_key = Philote::AccessKey.create(
+    read: %w(mychannel), write: %w(mychannel), allowed_uses: 5, uses: 3)
+
+  assert_equal %w(mychannel), access_key.read
+  assert_equal %w(mychannel), access_key.write
+  assert_equal 5, access_key.allowed_uses
+  assert_equal 3, access_key.uses
+
+  access_key = Philote::AccessKey.load(access_key.token)
+
+  assert !access_key.nil?
+  assert access_key.is_a?(Philote::AccessKey)
+  assert_equal %w(mychannel), access_key.read
+  assert_equal %w(mychannel), access_key.write
+  assert_equal 5, access_key.allowed_uses
+  assert_equal 3, access_key.uses
+  assert !access_key.token.nil?
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: philote
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.3.0
 platform: ruby
 authors:
 - pote
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-06-16 00:00:00.000000000 Z
+date: 2016-06-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redic
@@ -37,10 +37,11 @@ files:
 - CONTRIBUTING.md
 - LICENSE
 - Makefile
+- README.md
 - lib/philote.rb
-- lib/philote/admin.rb
 - lib/philote/version.rb
 - philote.gemspec
+- test/access_key_test.rb
 homepage: https://github.com/pote/philote-rb
 licenses:
 - MIT

data/lib/philote/admin.rb

@@ -1,18 +0,0 @@
-module Philote::Admin
-  def self.create_token(read: [], write: [], allowed_uses: 1)
-    permissions = {
-      read: read,
-      write: write,
-      allowed_uses: allowed_uses,
-      uses: 0
-    }
-
-    token = SecureRandom.urlsafe_base64
-
-    Philote.redis.call('SET', "philote:access_key:#{token}", permissions.to_json )
-  end
-
-  def self.publish(channel, message)
-    Philote.redis.call('PUBLISH', channel, message )
-  end
-end