RubyGems - tuppari - Versions diffs - 0.1.1 - Mend

tuppari 0.1.1

Files changed (16) hide show

data/.gitignore +6 -0
data/Gemfile +8 -0
data/README.md +94 -0
data/lib/tuppari.rb +41 -0
data/lib/tuppari/application.rb +16 -0
data/lib/tuppari/auth.rb +107 -0
data/lib/tuppari/authentication_error.rb +6 -0
data/lib/tuppari/client.rb +290 -0
data/lib/tuppari/client_error.rb +6 -0
data/lib/tuppari/server_url.rb +19 -0
data/lib/tuppari/version.rb +6 -0
data/spec/README.md +6 -0
data/spec/tuppari/auth_spec.rb +128 -0
data/spec/tuppari_spec.rb +111 -0
data/tuppari.gemspec +28 -0
metadata +96 -0

data/.gitignore ADDED Viewed

@@ -0,0 +1,6 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+.DS_Store
+.idea

data/Gemfile ADDED Viewed

@@ -0,0 +1,8 @@
+source "https://rubygems.org"
+gem 'rest-client', '1.6.7'
+gem 'json', '1.7.4'
+gem 'debugger'
+gem 'rspec'

data/README.md ADDED Viewed

@@ -0,0 +1,94 @@
+# Tuppari client for Ruby
+## About Tuppari
+[Tuppari](http://hakobera.github.com/tuppari/) is an experimental implementation of unbreakable message broadcasting system using WebSocket and Amazon Web Services by [@hakobera](https://github.com/hakobera).
+https://github.com/hakobera/tuppari
+https://github.com/hakobera/tuppari-servers
+## Tuppari for Ruby developers
+You can easily build a Tuppari application by just using Ruby API. Let's get started now!
+### Gemfile
+Prepare Gemfile as follows.
+```ruby
+source 'https://rubygems.org'
+gem 'tuppari'
+```
+### Getting Started
+And then invoke `bundle console` to try Tuppari.
+```ruby
+require 'tuppari'
+Tuppari.create_account(YOUR_ID, PASSWORD)
+tuppari = Tuppari.login(YOUR_ID, PASSWORD)
+application = tuppari.create_application('first-tuppari')
+open('tuppari.html', 'w') do |f|
+  html = <<"EOF"
+<html>
+  <head>
+  <script src="http://cdn.tuppari.com/0.1.0/tuppari.min.js"></script>
+  <script>
+    var client, channel;
+    client = tuppari.createClient({applicationId: '#{application.id}'});
+    channel = client.subscribe('ch');
+    channel.bind('update', function (msg) {
+      console.log(msg);
+    });
+  </script>
+  </head>
+  <body>Check JavaScript console.</body>
+</html>
+EOF
+  f.write(html)
+end
+#
+# [notice] Please open this 'tuppari.html' file in browser.
+#
+tuppari.application = application # or tuppari.load_application_by_name('first-tuppari')
+tuppari.publish_message(
+  :channel => 'ch',
+  :event => 'update',
+  :message => "Hello, Tuppari! (#{Time.now})"
+)
+```
+### Publishing messages without account authentication
+Tuppari account authentication is not needed for publishing messages. And following values for the target application are required.
+- application_id
+- access_key_id (for the application)
+- access_secret_key (for the application)
+```ruby
+application = Tuppari::Application.new(
+  :id => 'xxxx',
+  :access_key_id => 'yyy',
+  :access_secret_key => 'zzz'
+) # or application = tuppari.get_application('first-tuppari')
+Tuppari.publish_message(
+  :application => application,
+  :channel => 'ch',
+  :event => 'update',
+  :message => "Hello, Tuppari! (#{Time.now})"
+)
+```

data/lib/tuppari.rb ADDED Viewed

@@ -0,0 +1,41 @@
+# -*- encoding: utf-8 -*-
+require 'logger'
+require 'json'
+require 'rest_client'
+require 'time'
+require 'tuppari/auth'
+require 'tuppari/application'
+require 'tuppari/authentication_error'
+require 'tuppari/client'
+require 'tuppari/client_error'
+require 'tuppari/server_url'
+# Tuppari API client
+#
+# `Tuppari` is an experimental implementation of unbreakable message broadcasting system
+# using WebSocket and Amazon Web Services.
+#
+# see also https://github.com/hakobera/tuppari-servers/wiki/API-Reference
+#
+module Tuppari
+  # Creates a new Tuppari::Client instance.
+  def self.new(params = {})
+    Tuppari::Client.new(params)
+  end
+  def self.create_account(account_name, password)
+    new().create_account(account_name, password)
+  end
+  def self.login(account_name, password)
+    new().login(account_name, password)
+  end
+  def self.publish_message(params)
+    Tuppari.new().publish_message(params)
+  end
+end

data/lib/tuppari/application.rb ADDED Viewed

@@ -0,0 +1,16 @@
+# -*- encoding: utf-8 -*-
+module Tuppari
+  class Application
+    attr_accessor :name, :id, :access_key_id, :access_secret_key
+    def initialize(params)
+      @name = params[:name]
+      @id = params[:id]
+      @access_key_id = params[:access_key_id]
+      @access_secret_key = params[:access_secret_key]
+    end
+  end
+end

data/lib/tuppari/auth.rb ADDED Viewed

@@ -0,0 +1,107 @@
+# -*- encoding: utf-8 -*-
+require 'openssl'
+require 'digest'
+require 'json'
+module Tuppari
+  module Auth
+    def self.create_canonical_uri(uri)
+      if %r{^http(s)*://}.match(uri)
+        uri.sub(%r{^http(s)*://[^/]+/}, '/')
+      elsif %r{^[^/]}.match(uri)
+        "/#{uri}"
+      else
+        uri
+      end
+    end
+    def self.create_canonical_query_string(query_string)
+      if query_string.nil?
+        ''
+      else
+        query_string.split("&").sort_by { |e| e.split("=").first }.join('&')
+      end
+    end
+    def self.create_canonical_headers(headers)
+      if headers.nil?
+        ''
+      else
+        downcase_keys(headers).to_a.sort_by { |k, v| k }.map { |k, v| "#{k}:#{v}" }.join("\n")
+      end
+    end
+    def self.create_signed_headers(headers)
+      if headers.nil?
+        ''
+      else
+        downcase_keys(headers).to_a.sort_by { |k, v| k }.map { |k, v| k }.join(';')
+      end
+    end
+    def self.create_body_hash(body_params)
+      sha256 = Digest::SHA256.new
+      digest = sha256.digest(JSON.unparse(body_params))
+      Digest.hexencode(digest)
+    end
+    def self.create_canonical_request(method, uri, query_string, headers, body_params)
+      request = []
+      request << method
+      request << create_canonical_uri(uri)
+      request << create_canonical_query_string(query_string)
+      request << create_canonical_headers(headers)
+      request << create_signed_headers(headers)
+      request << create_body_hash(body_params)
+      request.join("\n")
+    end
+    def self.create_string_to_sign(canonical_request, request_time)
+      result = []
+      result << "SHA256"
+      result << request_time.gmtime.strftime("%Y%m%dT%H%M%SZ")
+      sha256 = Digest::SHA256.new
+      digest = sha256.digest(canonical_request)
+      result << Digest.hexencode(digest)
+      result.join("\n")
+    end
+    def self.create_signature(secret, string_to_sign, request_time, host)
+      signing_key = create_hmac_hash_value(create_hmac_hash_value("TUPPARI#{secret}", request_time.gmtime.strftime("%Y%m%dT%H%M%SZ")), host)
+      create_hmac_hash_value(signing_key, string_to_sign)
+    end
+    def self.create_authorization_header(params)
+      id = params[:id]
+      secret = params[:secret]
+      method = params[:method] || 'POST'
+      uri = params[:uri]
+      host = params[:host] || 'api.tuppari.com'
+      query_string = params[:query_string] || ''
+      headers = params[:headers] || {}
+      body_params = params[:body_params] || {}
+      request_time = params[:request_time] || Time.now
+      signed_headers = create_signed_headers(headers)
+      canonical_request = create_canonical_request(method, uri, query_string, headers, body_params)
+      string_to_sign = create_string_to_sign(canonical_request, request_time)
+      signature = create_signature(secret, string_to_sign, request_time, host)
+      "HMAC-SHA256 Credential=#{id},SignedHeaders=#{signed_headers},Signature=#{signature}"
+    end
+    protected
+    def self.downcase_keys(headers)
+      headers.each_with_object({}) { |(k, v), hash|
+        hash[k.downcase] = v
+      }
+    end
+    def self.create_hmac_hash_value(key, data)
+      OpenSSL::HMAC.hexdigest('sha256', key, data)
+    end
+  end
+end

data/lib/tuppari/authentication_error.rb ADDED Viewed

@@ -0,0 +1,6 @@
+# -*- encoding: utf-8 -*-
+module Tuppari
+  class AuthenticationError < Exception
+  end
+end

data/lib/tuppari/client.rb ADDED Viewed

@@ -0,0 +1,290 @@
+# -*- encoding: utf-8 -*-
+require 'logger'
+require 'time'
+require 'json'
+require 'rest_client'
+require 'tuppari'
+module Tuppari
+  class Client
+    attr_accessor :account_name, :account_secret, :application, :log
+    def initialize(params = {})
+      @log = Logger.new(params[:log_output] || STDOUT)
+      @log.level = params[:log_level] || Logger::INFO
+      @account_name = params[:account_name]
+      @account_secret = params[:account_secret]
+      setup_application(params)
+    end
+    def load_application_by_name(application_name)
+      setup_application({:application_name => application_name})
+      self
+    end
+    def create_account(account_name, password)
+      body = JSON.unparse({"accountName" => account_name, "password" => password})
+      begin
+        RestClient.post(Tuppari::ServerURL::ACCOUNTS_REGISTER, body, :content_type => :json)
+      rescue RestClient::Exception => e
+        @log.warn("Failed to create a new Tuppari account (#{e}, #{e.http_body})")
+        raise e
+      rescue Exception => e
+        @log.warn("Failed to create a new Tuppari account (#{e})")
+        raise e
+      end
+    end
+    def login(account_name, password)
+      body = JSON.unparse({:accountName => account_name, :password => password})
+      begin
+        body = RestClient.post(Tuppari::ServerURL::ACCOUNTS_AUTH, body, :content_type => :json)
+        credentials = JSON.parse(body)['credentials']
+        @account_name = credentials['id']
+        @account_secret = credentials['secret']
+        @log.debug {
+          "Authenticated tuppari user (account_name:#{@account_name}, account_secret:#{@account_secret})"
+        }
+      rescue RestClient::Exception => e
+        @log.warn("Failed to authenticate your Tuppari account (#{e}, #{e.http_body})")
+        raise e
+      rescue Exception => e
+        @log.warn("Failed to authenticate your Tuppari account (#{e})")
+        raise e
+      end
+      self
+    end
+    def is_authenticated?
+      !@account_name.nil? && !@account_secret.nil?
+    end
+    def create_application(application_name)
+      unless is_authenticated?
+        raise Tuppari::AuthenticationError.new("Call #authenticate(account_name, password) before.")
+      end
+      time = Time.now
+      headers = headers('CreateApplication', time)
+      body_params = {:applicationName => application_name.to_s}
+      auth_header = Tuppari::Auth.create_authorization_header(
+          :id => @account_name,
+          :secret => @account_secret,
+          :method => 'POST',
+          :uri => Tuppari::ServerURL::APPLICATIONS,
+          :host => 'api.tuppari.com',
+          :query_string => '',
+          :headers => headers,
+          :body_params => body_params,
+          :request_time => time
+      )
+      begin
+        body = RestClient.post(Tuppari::ServerURL::APPLICATIONS,
+                               JSON.unparse(body_params),
+                               headers.merge(:authorization => auth_header))
+        @log.debug {
+          "create_application response: #{body}"
+        }
+        @log.info {
+          "Tuppari application is created. (#{application_name})"
+        }
+        response = JSON.parse(body)
+        Tuppari::Application.new(
+            :name => response['applicationName'],
+            :id => response['applicationId'],
+            :access_key_id => response['accessKeyId'],
+            :access_secret_key => response['accessSecretKey']
+        )
+      rescue RestClient::Exception => e
+        @log.warn("Failed to create a new Tuppari application (#{e}, #{e.http_body})")
+        raise e
+      rescue Exception => e
+        @log.warn("Failed to create a new Tuppari application (#{e})")
+        raise e
+      end
+    end
+    def delete_application(application_name)
+      unless is_authenticated?
+        raise Tuppari::AuthenticationError.new("Call #authenticate(account_name, password) before.")
+      end
+      time = Time.now
+      headers = headers('DeleteApplication', time)
+      body_params = {:applicationName => application_name}
+      auth_header = Tuppari::Auth.create_authorization_header(
+          :id => @account_name,
+          :secret => @account_secret,
+          :method => 'POST',
+          :uri => Tuppari::ServerURL::APPLICATIONS,
+          :host => 'api.tuppari.com',
+          :query_string => '',
+          :headers => headers,
+          :body_params => body_params,
+          :request_time => time
+      )
+      begin
+        RestClient.post(Tuppari::ServerURL::APPLICATIONS,
+                        JSON.unparse(body_params),
+                        headers.merge(:authorization => auth_header))
+        @log.info {
+          "Tuppari application is deleted. (#{application_name})"
+        }
+      rescue RestClient::Exception => e
+        @log.warn("Failed to delete a Tuppari application (#{e}, #{e.http_body})")
+        raise e
+      rescue Exception => e
+        @log.warn("Failed to delete a Tuppari application (#{e})")
+        raise e
+      end
+      nil
+    end
+    def get_application(application_name)
+      get_application_list().find { |app| app.name == application_name }
+    end
+    def get_application_list()
+      unless is_authenticated?
+        raise Tuppari::AuthenticationError.new("Call #authenticate(account_name, password) before.")
+      end
+      time = Time.now
+      headers = headers('ListApplication', time)
+      body_params = {}
+      auth_header = Tuppari::Auth.create_authorization_header(
+          :id => @account_name,
+          :secret => @account_secret,
+          :method => 'POST',
+          :uri => Tuppari::ServerURL::APPLICATIONS,
+          :host => 'api.tuppari.com',
+          :query_string => '',
+          :headers => headers,
+          :body_params => body_params,
+          :request_time => time
+      )
+      begin
+        body = RestClient.post(Tuppari::ServerURL::APPLICATIONS,
+                               JSON.unparse(body_params),
+                               headers.merge(:authorization => auth_header))
+        @log.debug {
+          "get_application_list response: #{response}"
+        }
+        JSON.parse(body).to_a.map { |name, app|
+          Tuppari::Application.new(
+              :name => app['name'],
+              :id => app['applicationId'],
+              :access_key_id => app['accessKeyId'],
+              :access_secret_key => app['accessSecretKey']
+          )
+        }
+      rescue RestClient::Exception => e
+        @log.warn("Failed to get the Tuppari application list (#{e}, #{e.http_body})")
+        raise e
+      rescue Exception => e
+        @log.warn("Failed to get the Tuppari application list (#{e})")
+        raise e
+      end
+    end
+    def publish_message(params)
+      setup_application(params)
+      if @application.nil?
+        raise Tuppari::ClientError.new("Specify Tuppari application to publish messages.")
+      end
+      channel = params[:channel]
+      event = params[:event]
+      message = params[:message]
+      time = Time.now
+      headers = headers('PublishMessage', time)
+      body_params = {
+          :applicationId => @application.id,
+          :channel => channel,
+          :event => event,
+          :message => message
+      }
+      auth_header = Tuppari::Auth.create_authorization_header(
+          :id => @application.access_key_id,
+          :secret => @application.access_secret_key,
+          :method => 'POST',
+          :uri => Tuppari::ServerURL::MESSAGES,
+          :host => 'api.tuppari.com',
+          :query_string => '',
+          :headers => headers,
+          :body_params => body_params,
+          :request_time => time
+      )
+      begin
+        body = RestClient.post(Tuppari::ServerURL::MESSAGES,
+                               JSON.unparse(body_params),
+                               headers.merge(:authorization => auth_header))
+        @log.debug {
+          "Tuppari message has been sent. (#{@application.id},#{channel},#{event},#{message})"
+        }
+        JSON.parse(body)
+      rescue RestClient::Exception => e
+        @log.warn {
+          "Failed to publish a Tuppari message (#{e}, #{e.http_body}, application_id:#{@application.id}, " +
+              "channel:#{channel}, event:#{event}, message:#{message})"
+        }
+        raise e
+      rescue Exception => e
+        @log.warn {
+          "Failed to publish a Tuppari message (#{e}, application_id:#{@application.id}, " +
+              "channel:#{channel}, event:#{event}, message:#{message})"
+        }
+        raise e
+      end
+    end
+    def get_service_info()
+      begin
+        body = RestClient.get(Tuppari::ServerURL::INFO, 'Content-type' => 'application/json')
+        JSON.parse(body)
+      rescue RestClient::Exception => e
+        @log.warn("Failed to get the Tuppari service info (#{e}, #{e.http_body})")
+        raise e
+      rescue Exception => e
+        @log.warn("Failed to get the Tuppari service info (#{e})")
+        raise e
+      end
+    end
+    protected
+    def setup_application(params)
+      if !params[:application].nil?
+        app = params[:application]
+        if app.is_a? Tuppari::Application
+          @application = app
+        else
+          raise Tuppari::ClientError.new("application should be a Tuppari::Application object.")
+        end
+      elsif !params[:application_name].nil?
+        application_name = params[:application_name]
+        application = get_application_list().find { |app| app.name == application_name }
+        if application.nil?
+          raise Tuppari::ClientError.new("Application is not found (application_name: #{application_name})")
+        else
+          @application = application
+        end
+      end
+    end
+    def headers(operation, time)
+      {
+          'Host' => 'api.tuppari.com',
+          'Content-type' => 'application/json',
+          'X-Tuppari-Date' => time.gmtime.rfc2822,
+          'X-Tuppari-Operation' => operation
+      }
+    end
+  end
+end

data/lib/tuppari/client_error.rb ADDED Viewed

@@ -0,0 +1,6 @@
+# -*- encoding: utf-8 -*-
+module Tuppari
+  class ClientError < Exception
+  end
+end

data/lib/tuppari/server_url.rb ADDED Viewed

@@ -0,0 +1,19 @@
+# -*- encoding: utf-8 -*-
+module Tuppari
+  module ServerURL
+    BASE_URL = 'https://api.tuppari.com'
+    ACCOUNTS_REGISTER = BASE_URL + '/accounts/register'
+    ACCOUNTS_AUTH = BASE_URL + '/accounts/auth'
+    APPLICATIONS = BASE_URL + '/applications'
+    MESSAGES = BASE_URL + '/messages'
+    INFO = BASE_URL + '/info'
+  end
+end

data/lib/tuppari/version.rb ADDED Viewed

@@ -0,0 +1,6 @@
+# -*- encoding: utf-8 -*-
+module Tuppari
+  VERSION = "0.1.1"
+end

data/spec/README.md ADDED Viewed

@@ -0,0 +1,6 @@
+Before testing, update your `~/.bash_profile` as follows:
+```sh
+export TUPPARI_ACCOUNT_NAME=YOUR_ACCOUNT
+export TUPPARI_PASSWORD=YOUR_PASSWORd
+```

data/spec/tuppari/auth_spec.rb ADDED Viewed

@@ -0,0 +1,128 @@
+# -*- encoding: utf-8 -*-
+require 'tuppari'
+describe Tuppari::Auth do
+  it "should have correct #create_canonical_uri" do
+    Tuppari::Auth.create_canonical_uri('foo/bar').should eq('/foo/bar')
+    Tuppari::Auth.create_canonical_uri('/foo/bar').should eq('/foo/bar')
+    Tuppari::Auth.create_canonical_uri('http://www.google.com/foo/bar').should eq('/foo/bar')
+  end
+  it "should have correct #create_canonical_query_string" do
+    Tuppari::Auth.create_canonical_query_string(nil).should eq('')
+    Tuppari::Auth.create_canonical_query_string('').should eq('')
+    Tuppari::Auth.create_canonical_query_string('a=b').should eq('a=b')
+    Tuppari::Auth.create_canonical_query_string('a=b&c=d').should eq('a=b&c=d')
+    Tuppari::Auth.create_canonical_query_string('c=d&a=b').should eq('a=b&c=d')
+    Tuppari::Auth.create_canonical_query_string('c=d&a=b&c=e').should eq('a=b&c=d&c=e')
+  end
+  it "should have correct #create_canonical_headers" do
+    Tuppari::Auth.create_canonical_headers(nil).should eq('')
+    Tuppari::Auth.create_canonical_headers({}).should eq('')
+    headers = {
+        'X-Tuppari-Operation' => 'CreateApplication',
+        'Content-type' => 'application/json',
+        'Host' => 'api.tuppari.com'
+    }
+    Tuppari::Auth.create_canonical_headers(headers).should eq("content-type:application/json\nhost:api.tuppari.com\nx-tuppari-operation:CreateApplication")
+  end
+  it "should have correct #create_signed_headers" do
+    Tuppari::Auth.create_signed_headers(nil).should eq('')
+    Tuppari::Auth.create_signed_headers({}).should eq('')
+    headers = {
+        'X-Tuppari-Operation' => 'CreateApplication',
+        'Content-type' => 'application/json',
+        'Host' => 'api.tuppari.com'
+    }
+    Tuppari::Auth.create_signed_headers(headers).should eq('content-type;host;x-tuppari-operation')
+  end
+  it 'should have correct #create_body_hash' do
+    Tuppari::Auth.create_body_hash({'a' => 'b', 'c' => 'd'}).should eq('b85c7da93e8790518898c280e15e3f1af5d46bf4aaa4407690f0f0a3b0316478')
+  end
+  it 'should have correct #create_canonical_request' do
+    headers = {
+        'X-Tuppari-Operation' => 'CreateApplication',
+        'Content-type' => 'application/json',
+        'Host' => 'api.tuppari.com'
+    }
+    body_params = {'applicationName' => 'example1'}
+    request = Tuppari::Auth.create_canonical_request('POST', '/test', 'b=v2&a=v1', headers, body_params)
+    request.should eq("POST\n" +
+                          "/test\n" +
+                          "a=v1&b=v2\n" +
+                          "content-type:application/json\n" +
+                          "host:api.tuppari.com\n" +
+                          "x-tuppari-operation:CreateApplication\n" +
+                          "content-type;host;x-tuppari-operation\n" +
+                          "8f2d5fe4a93000d3546e578d265fc936806f6ef6dc6f7ee87715e1a5c514c168")
+  end
+  it 'should have correct #create_string_to_sign' do
+    request = "POST\n" +
+        "/test\n" +
+        "a=v1&b=v2\n" +
+        "content-type:application/json\n" +
+        "host:api.tuppari.com\n" +
+        "x-tuppari-operation:CreateApplication\n" +
+        "content-type;host;x-tuppari-operation\n" +
+        "8f2d5fe4a93000d3546e578d265fc936806f6ef6dc6f7ee87715e1a5c514c168"
+    Tuppari::Auth.create_string_to_sign(request, Time.new(2011, 2, 3, 4, 5, 6)).should(
+        eq("SHA256\n" +"20110202T190506Z\n" +"152176000cc08c7d9d0558bc3a50368aa38619a695ad20f50bec1344429cb315"))
+  end
+  it 'should have correct #create_signature' do
+    secret = 'secretKey1'
+    string_to_sign = "SHA256\n" +
+        "19700101T000000Z\n" +
+        "152176000cc08c7d9d0558bc3a50368aa38619a695ad20f50bec1344429cb315"
+    time = Time.new(1970, 1, 1, 0, 0, 0, "+00:00")
+    host = 'api.tuppari.com'
+    expected_signature = '4815ff1681a278e7c852902ea3604f17831a80a78dc0ff82f5142598a034509b'
+    (1...1000).each do |i|
+      signature = Tuppari::Auth.create_signature(secret, string_to_sign, time, host)
+      signature.should eq(expected_signature)
+    end
+    secret2 = 'secretKey2'
+    signature1 = Tuppari::Auth.create_signature(secret, string_to_sign, time, host)
+    signature2 = Tuppari::Auth.create_signature(secret2, string_to_sign, time, host)
+    signature2.should_not eq(signature1)
+  end
+  it 'should have correct #create_authorization_header' do
+    header = Tuppari::Auth.create_authorization_header(
+        :id => 'accessKeyId',
+        :secret => 'accessSecretKey',
+        :method => 'POST',
+        :host => 'api.tuppari.com',
+        :uri => '/test',
+        :query_string => 'a=v1&b=v2',
+        :headers => {
+            'Host' => 'api.tuppari.com',
+            'Content-Type' => 'application/json',
+            'X-Tuppari-Operation' => 'CreateApplication'
+        },
+        :body_params => {
+            'applicationName' => 'example1'
+        },
+        :request_time => Time.new(1970, 1, 1, 0, 0, 0, "+00:00")
+    )
+    header.should eq("HMAC-SHA256 Credential=accessKeyId,SignedHeaders=content-type;host;x-tuppari-operation,Signature=050f8711271747d4f63a3caa3ffb420e4cd5a0e9d9dda8ba7e4faad6794c40d0")
+  end
+  it 'should have correct #create_hmac_hash_value' do
+    result = Tuppari::Auth.create_hmac_hash_value('123', 'abc')
+    result.should eq('8f16771f9f8851b26f4d460fa17de93e2711c7e51337cb8a608a0f81e1c1b6ae')
+  end
+end

data/spec/tuppari_spec.rb ADDED Viewed

@@ -0,0 +1,111 @@
+# -*- encoding: utf-8 -*-
+require 'tuppari'
+require 'logger'
+require 'ruby-debug'
+describe Tuppari do
+  account_name = ENV['TUPPARI_ACCOUNT_NAME']
+  password = ENV['TUPPARI_PASSWORD']
+=begin
+  it "should create a new account" do
+    tuppari = Tuppari.new()
+    response = tuppari.create_account("account_name", "password")
+    puts response
+  end
+  it "should create a new account" do
+    tuppari = Tuppari.new(:account_name => account_name, :account_secret => account_secret)
+    response = tuppari.delete_application("application_name")
+    puts response
+  end
+=end
+  it "should be created with account_name/account_secret" do
+    tuppari = Tuppari.new(
+        :account_name => account_name,
+        :account_secret => Tuppari.login(account_name, password).account_secret
+    )
+    tuppari.is_authenticated?.should eq(true)
+  end
+  it "should login" do
+    tuppari = Tuppari.new()
+    tuppari.is_authenticated?.should eq(false)
+    tuppari.login(account_name, password)
+    tuppari.is_authenticated?.should eq(true)
+  end
+  it "should raise Tuppari::AuthenticationError when creating a new applications without authentication" do
+    tuppari = Tuppari.new()
+    name = Time.now.tv_sec.to_s
+    begin
+      tuppari.create_application(name)
+      fail()
+    rescue Tuppari::AuthenticationError
+    end
+  end
+  it "should create a new application" do
+    tuppari = Tuppari.new(:log_level => Logger::WARN).login(account_name, password)
+    name = Time.now.tv_sec.to_s
+    app = tuppari.create_application(name)
+    app.name.should eq(name)
+    app.id.nil?.should eq(false)
+    app.access_key_id.nil?.should eq(false)
+    app.access_secret_key.nil?.should eq(false)
+  end
+  it "should raise Tuppari::AuthenticationError when getting my application list without authentication" do
+    tuppari = Tuppari.new()
+    begin
+      tuppari.get_application_list()
+      fail()
+    rescue Tuppari::AuthenticationError
+    end
+  end
+  it "should get my application list" do
+    tuppari = Tuppari.new(:log_level => Logger::WARN).login(account_name, password)
+    response = tuppari.get_application_list()
+    response.size.should > 0
+  end
+  it "should raise Tuppari::AuthenticationError when publishing messages without authentication" do
+    tuppari = Tuppari.new()
+    begin
+      response = tuppari.publish_message(
+          :application_name => 'tuppari-sample',
+          :channel => 'channel_name',
+          :event => 'event_name',
+          :message => 'Hello, Tuppari!'
+      )
+      fail()
+    rescue Tuppari::AuthenticationError
+    end
+  end
+  it "should publish messages" do
+    tuppari = Tuppari.new(:log_level => Logger::WARN).login(account_name, password)
+    response = tuppari.publish_message(
+        :application_name => 'tuppari-sample',
+        :channel => 'channel_name',
+        :event => 'event_name',
+        :message => 'Hello, Tuppari!'
+    )
+    response.size.should > 0
+  end
+  it "should get the service info" do
+    info = Tuppari.new().get_service_info()
+    info['name'].should eq("gyoji")
+    info['version'].nil?.should eq(false)
+  end
+end

data/tuppari.gemspec ADDED Viewed

@@ -0,0 +1,28 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "tuppari/version"
+Gem::Specification.new do |s|
+  s.name = "tuppari"
+  s.version = Tuppari::VERSION
+  s.authors = ["Kazuhiro Sera"]
+  s.email = ["seratch@gmail.com"]
+  s.homepage = "https://github.com/tuppari/tuppari-ruby"
+  s.summary = %q{Tuppari client for Ruby}
+  s.description = %q{Tuppari is an experimental implementation of unbreakable message broadcasting system using WebSocket and Amazon Web Services by @hakobera.}
+  s.rubyforge_project = "tuppari"
+  s.files = `git ls-files`.split("\n")
+  s.test_files = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
+  s.require_paths = ["lib"]
+  s.required_ruby_version = '>= 1.9.0'
+  s.add_dependency('rest-client', '1.6.7')
+  s.add_dependency('json', '1.7.4')
+end

metadata ADDED Viewed

@@ -0,0 +1,96 @@
+--- !ruby/object:Gem::Specification
+name: tuppari
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+  prerelease:
+platform: ruby
+authors:
+- Kazuhiro Sera
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2012-08-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rest-client
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.6.7
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.6.7
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.7.4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.7.4
+description: Tuppari is an experimental implementation of unbreakable message broadcasting
+  system using WebSocket and Amazon Web Services by @hakobera.
+email:
+- seratch@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- README.md
+- lib/tuppari.rb
+- lib/tuppari/application.rb
+- lib/tuppari/auth.rb
+- lib/tuppari/authentication_error.rb
+- lib/tuppari/client.rb
+- lib/tuppari/client_error.rb
+- lib/tuppari/server_url.rb
+- lib/tuppari/version.rb
+- spec/README.md
+- spec/tuppari/auth_spec.rb
+- spec/tuppari_spec.rb
+- tuppari.gemspec
+homepage: https://github.com/tuppari/tuppari-ruby
+licenses: []
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: tuppari
+rubygems_version: 1.8.24
+signing_key:
+specification_version: 3
+summary: Tuppari client for Ruby
+test_files:
+- spec/README.md
+- spec/tuppari/auth_spec.rb
+- spec/tuppari_spec.rb