em-ucengine 0.1.1 → 0.3.0

data/lib/em-ucengine/brick_test.rb

@@ -0,0 +1,27 @@
+module EventMachine
+  module UCEngine
+    module Brick
+      # A simple class to allowing you to test your bricks
+      module Test
+        # Return the instance of the brick
+        def brick
+          return @b unless @b.nil?
+          @b = app.new
+          @b.start MiniTest::Mock.new
+          @b
+        end
+
+        # Trigger a U.C.Engine event into the brick
+        #
+        # @param [String] name
+        # @param [Hash] data
+        def trigger(name, data={})
+          event = data.merge "type" => name
+          brick.routes[name].each do |proc|
+            brick.instance_exec(event, &proc)
+          end unless brick.routes[name].nil?
+        end
+      end
+    end
+  end
+end

data/lib/em-ucengine/client.rb

@@ -0,0 +1,268 @@
+# -*- coding: utf-8 -*-
+require "uri"
+require "json"
+
+
+module UCEngine
+  class Client
+
+    # Create a new U.C.Engine client
+    #
+    # @param [String] Host of the U.C.Engine instance
+    # @param [Number] Port of the U.C.Engine instance
+    # @param [String] Entry point of the API
+    # @param [String] Version of U.C.Engine API
+    def initialize(host="localhost", port=5280, api_root="/api", api_version="0.6")
+      @host = host
+      @port = port
+      @root = api_root
+      @version = api_version
+    end
+
+    # Format url to api
+    #
+    # @param [String] Path of the method
+    def url(path)
+      URI.escape("http://#{@host}:#{@port}#{@root}/#{@version}#{path}")
+    end
+
+    # Get server time
+    def time(&block)
+      Session.new(self, nil, nil).time &block
+    end
+
+    # Connect to U.C.Engine
+    #
+    # @param [String] User name
+    # @param [String] Password
+    # @param [Hash] Metadata of the user
+    def connect(user, password, metadata=nil, &block)
+      body = { "name" => user, "credential" => password }
+      body["metadata"] = metadata if metadata
+      req = post(url("/presence"), {}, body)
+      answer_connect(req, &block)
+    end
+
+    # Create a user
+    #
+    # @param [Hash] data
+    def create_user(data)
+      # FIXME: for now users can't be created with metadata.
+      answer post("/user", data), &block
+    end
+
+    # Session represent the U.C.Engine client with and sid and uid
+    # See #connect
+    class Session < Struct.new(:uce, :uid, :sid)
+      def url(*args)
+        uce.url(*args)
+      end
+
+      ### Time - http://docs.ucengine.org/api.html#time ###
+
+      # Get server time
+      def time(&block)
+        answer get(url("/time")), &block
+      end
+
+      ### Presence - http://docs.ucengine.org/api.html#authentication ###
+
+      # Get infos on the presence
+      #
+      # @param [String] Sid
+      def presence(sid, &block)
+        answer get(url("/presence/#{sid}")), &block
+      end
+
+      # Disconnect a user
+      #
+      # @param [String] Sid
+      def disconnect(sid, &block)
+        answer delete(url "/presence/#{sid}"), &block
+      end
+
+      ### Users - http://docs.ucengine.org/api.html#user ###
+
+      # List users
+      def users(&block)
+        answer get(url "/user"), &block
+      end
+
+      # Get user info
+      #
+      # @param [String] uid
+      def user(uid, &block)
+        answer get(url("/user/#{uid}")), &block
+      end
+
+      # Create user
+      #
+      # @param [Hash] data
+      def create_user(data, &block)
+        answer post(url("/user"), data), &block
+      end
+
+      # Update user
+      #
+      # @param [String] uid
+      # @param [Hash] data
+      def update_user(uid, data, &block)
+        answer put(url("/user/#{uid}"), data), &block
+      end
+
+      # Delete a user
+      #
+      # @param [String] uid
+      def delete_user(uid, &block)
+        answer delete(url("/user/#{uid}")), &block
+      end
+
+      # Check user ACL
+      #
+      # @param [String] uid
+      # @param [String] action
+      # @param [String] object
+      # @param [Hash] conditions
+      # @param [String] meeting name
+      def user_can(uid, action, object, conditions={}, location="", &block)
+        answer_bool get(url("/user/#{uid}/can/#{action}/#{object}/#{location}"), :conditions => conditions), &block
+      end
+
+      ### Meetings - http://docs.ucengine.org/api.html#meeting ###
+
+      # List meetings
+      #
+      def meetings(&block)
+        answer get(url "/meeting/"), &block
+      end
+
+      # Get meeting
+      #
+      # @param [String] meeting
+      def meeting(meeting, &block)
+        answer get(url "/meeting/#{meeting}"), &block
+      end
+
+      # Create a meeting
+      #
+      # @param [String] meeting name
+      # @param [Hash] metadata
+      def create_meeting(meeting, body={}, &block)
+        body.merge!(:name => meeting)
+        answer post(url("/meeting/"), body), &block
+      end
+
+      # Update a meeting
+      #
+      # @param [String] meeting name
+      # @param [Hash] metadata
+      def update_meeting(meeting, body={}, &block)
+        answer put(url "/meeting//#{meeting}", body), &block
+      end
+
+      ### Rosters - http://docs.ucengine.org/api.html#join-a-meeting ###
+
+      # List users on the meeting
+      #
+      # @param [String] meeting
+      def roster(meeting, &block)
+        answer get(url "/meeting/#{meeting}/roster"), &block
+      end
+
+      # Join the meeting
+      #
+      # @param [String] meeting
+      def join_roster(meeting, body={}, &block)
+        answer post(url "/meeting/#{meeting}/roster", body), &block
+      end
+
+      # Quit the meeting
+      #
+      # @param [String] meeting
+      # @param [String] uid
+      def quit_roster(meeting, uid=nil, &block)
+        answer delete(url "/meeting/#{meeting}/roster/#{uid || @uid}"), &block
+      end
+
+      ### Events - http://docs.ucengine.org/api.html#events ###
+
+      # Get events
+      #
+      # @param [String] meeting
+      # @param [Hash] params
+      def events(meeting=nil, params={}, &block)
+        answer get(url("/event/#{meeting}"), params), &block
+      end
+
+      # Publish event
+      #
+      # @param [String] type
+      # @param [String] meeting
+      # @param [Hash] metadata
+      def publish(type, meeting=nil, metadata=nil, parent=nil, &block)
+        args = { :type => type, :uid => uid, :sid => sid }
+        args[:parent] = parent if parent
+        args[:metadata] = metadata if metadata
+        answer json_post(url("/event/#{meeting}"), args), &block
+      end
+
+      # Get event
+      #
+      # @param [String] id
+      def event(id, &block)
+        # Fixme: remove meeting fake param on the 0.7 release
+        answer get(url("/event/meeting/#{id}"), {}), &block
+      end
+
+      # Search
+      #
+      # @param [Hash] params
+      def search(params, &block)
+        answer get(url "/search/event/", params, &block)
+      end
+
+      ### Files - http://docs.ucengine.org/api.html#upload-a-file ###
+
+      # Delete a file
+      #
+      # @param [String] meeting
+      # @param [String] filename
+      def delete_file(meeting, filename, &block)
+        answer delete(url("/file/#{meeting}/#{filename}")), &block
+      end
+
+      # List files on a meeting room
+      #
+      # @param [String] meeting
+      # @param [Hash] params
+      def files(meeting, params={}, &block)
+        answer get(url("/file/#{meeting}"), params), &block
+      end
+
+      ### Roles - http://docs.ucengine.org/api.html#roles ###
+
+      # Create a role
+      #
+      # @param [Hash] data
+      def create_role(data, &block)
+        answer post(url("/role/"), data), &block
+      end
+
+      # Delete a role
+      #
+      # @param [String] name
+      def delete_role(name, &block)
+        answer delete(url "/role/#{name}"), &block
+      end
+
+      # Set a role to a user
+      #
+      # @param [String] uid
+      # @param [Hash] params
+      def user_role(uid, params={}, &block)
+        answer post(url("/user/#{uid}/roles"), params), &block
+      end
+    end
+  end
+end
+

data/lib/em-ucengine/client_em.rb

@@ -0,0 +1,239 @@
+require "eventmachine"
+require "em-http-request"
+require "em-http/middleware/json_response"
+require "multipart_body"
+require "em-eventsource"
+
+require_relative "errors"
+
+module EventMachine
+  module UCEngine
+    # Use response as block
+    module EventMachineResponse
+      def answer(req, &block)
+        response = EM::DefaultDeferrable.new
+        req.errback do
+          error = UCEngine::Client::HttpError.new(0, "connect error", req.last_effective_url)
+          response.fail error
+          yield error, nil if block_given?
+        end
+        req.callback do
+          data = req.response
+          if data["error"]
+            error = UCEngine::Client::UCError.new(req.response_header.status, data["error"], req.last_effective_url)
+            response.fail error
+            yield error, nil if block_given?
+          else
+            response.succeed data["result"]
+            yield nil, data["result"] if block_given?
+          end
+        end
+        response
+      end
+
+      def answer_bool(req, &block)
+        answer(req) do |err, result|
+          result = (result == "true")
+          yield nil, result if block_given?
+        end
+      end
+
+      def answer_download(req)
+        response = EM::DefaultDeferrable.new
+        req.errback do
+          error = UCEngine::Client::HttpError.new(0, "connect error", req.last_effective_url)
+          response.fail error
+          yield error, nil if block_given?
+        end
+        req.callback do
+          if req.response_header.status == 200
+            data = req.response
+            filename = req.response_header['CONTENT_DISPOSITION']
+            file = Tempfile.new(filename)
+            file.write(data)
+            response.succeed file
+            yield nil, file if block_given?
+          else
+            error = UCEngine::Client::HttpError.new(0, "download error")
+            response.fail error
+            yield error, nil if block_given?
+          end
+        end
+        response
+      end
+
+      def answer_connect(http)
+        response = EM::DefaultDeferrable.new
+        http.errback do
+          error = UCEngine::Client::HttpError.new(0, "connect error", http.uri)
+          response.fail error
+          yield error, nil if block_given?
+        end
+        http.callback do
+          if http.response_header.status >= 500
+            error = UCEngine::Client::HttpError.new(http.response_header.status, http.response, http.uri)
+            response.fail error
+            yield error, nil if block_given?
+          else
+            data = http.response
+            if data['error']
+              error = UCEngine::Client::UCError.new(http.response_header.status, data['error'], http.req.uri.to_s)
+              response.fail error
+              yield error, nil if block_given?
+            else
+              result = data["result"]
+              session = UCEngine::Client::Session.new(self, result["uid"], result["sid"])
+              response.succeed session
+              yield nil, session if block_given?
+            end
+          end
+        end
+        response
+      end
+    end
+
+    module EventMachineRequest
+      def http_request(method, path, params={}, body={}, session=nil, headers=nil, &block)
+        opts ||= {:query => params, :body => body, :head => headers}
+
+        key = (method == :get || method == :delete) ? :query : :body
+        opts[key].merge!(:uid => self.uid, :sid => self.sid) if self.class == UCEngine::Client::Session
+
+        # TODO: make a em-http-request middleware
+        if headers && headers['Content-Type'] == 'application/json'
+          opts[key] = opts[key].to_json
+        end
+
+        conn = EM::HttpRequest.new(path)
+        req = conn.send(method, opts)
+        req
+      end
+
+      def get(path, params={}, body={}, session=nil, headers=nil)
+        http_request(:get, path, params, body, session, headers)
+      end
+
+      def post(path, params={}, body={}, session=nil, headers={})
+        http_request(:post, path, params, body, session, headers)
+      end
+
+      def put(path, params={}, body={}, session=nil, headers={})
+        http_request(:put, path, params, body, session, headers)
+      end
+
+      def delete(path, params={}, body={}, session=nil, headers={})
+        http_request(:delete, path, params, body, session, headers)
+      end
+
+      # Perform a post request on the API with a content type application/json
+      #
+      # @param [String] path
+      # @param [Hash] body
+      def json_post(path, body)
+        http_request(:post, path, {}, body, nil, {'Content-Type' => 'application/json'})
+      end
+    end
+
+    class Client < ::UCEngine::Client
+      include UCEngine::EventMachineResponse
+      include UCEngine::EventMachineRequest
+
+      EM::HttpRequest.use EM::Middleware::JSONResponse
+
+      def time(&block)
+        Session.new(self, nil, nil).time &block
+      end
+
+      # Init EventMachine and init a new instance of U.C.Engine client
+      # See #initialize for arguments
+      def self.run(*args)
+        EM.run {  yield self.new(*args) }
+      end
+
+      # Represent a subscription to the U.C.Engine API
+      # Use #subscribe to create a new one
+      class Subscription < EM::EventSource
+        # Start subscription
+        def start(start)
+          @query[:start] = start
+          super()
+        end
+
+        # Cancel subscription
+        def cancel
+          close
+          yield if block_given?
+        end
+      end
+
+      class Session < ::UCEngine::Client::Session
+        include UCEngine::EventMachineResponse
+        include UCEngine::EventMachineRequest
+
+        # Subscribe to events
+        #
+        # @param [String] meeting
+        # @param [Hash] params
+        # @return Subscription
+        def subscribe(meeting, params={}, &block)
+          params[:mode] = "eventsource"
+          params.merge!(:uid => uid, :sid => sid)
+          s = Subscription.new(url("/live/#{meeting}"), params)
+          time do |err, now|
+            s.message do |message|
+              block.call(nil, [JSON.parse(message)])
+            end
+            s.error do |error|
+              if s.ready_state != EM::EventSource::CONNECTING
+                puts error
+                block.call error, nil
+              end
+            end
+            s.start(now)
+          end
+          s
+        end
+
+        # Upload a file in a meeting room
+        #
+        # @param [String] meeting name
+        # @param [File] file
+        # @param [Hash] metadata
+        def upload(meeting, file, metadata={}, &block)
+          partfile = Part.new( :name => 'content',
+                               :filename => File.basename(file.path),
+                               :body =>  file.read)
+          partuid = Part.new( :name => 'uid',
+                              :body => uid)
+          partsid = Part.new( :name => 'sid',
+                              :body => sid)
+          parts = [partfile, partsid, partuid]
+          parts << metadata.inject([]) { |array, (key, value)|
+            array << Part.new( :name => "metadata[#{key}]",
+                               :body => value )
+          }
+
+          body = MultipartBody.new(parts)
+
+          conn = EM::HttpRequest.new(uce.url "/file/#{meeting}")
+          req = conn.post( :head => {'content-type' => "multipart/form-data; boundary=#{body.boundary}"},
+                           :body => "#{body.to_s}\r\n")
+          answer(req, &block)
+        end
+
+        # Download a file
+        # The result will a File object
+        # uce.download("demo", "myfile") do |err, file|
+        #    puts file.open.read
+        # end
+        #
+        # @param [String] meeting
+        # @param [String] filename
+        def download(meeting, filename, &block)
+          answer_download get(url("/file/#{meeting}/#{filename}")), &block
+        end
+
+      end
+    end
+  end
+end