shove 0.52 → 1.0.1

data/lib/shove/app.rb

@@ -0,0 +1,78 @@
+module Shove
+  class App
+
+    attr_accessor :config
+
+    # create an API client
+    # +config+ optional Confstruct
+    # +&block+ config block
+    # Example:
+    # Shove::App.new do
+    #   app_id "myappid"
+    #   app_key "myappkey"
+    # end
+    def initialize config=Confstruct::Configuration.new, &block
+      @config = config
+      configure(&block)
+    end
+
+    def configure params={}, &block
+      if params
+        @config.configure params
+      end
+      
+      if block
+        @config.configure(&block)
+      end
+
+      unless @config.app_id && @config.app_key
+        raise ShoveException.new("App ID and App Key are required")
+      end
+    end
+
+    # is the app valid?
+    # do the app_id and app_key work with the remote
+    def valid?
+      !request("validate").exec_sync(:get).error?
+    end
+    
+    # get a list of websocket hosts
+    def hosts
+      request("hosts").exec_sync(:get).parse
+    end
+
+    # create a channel context for acting on a channel
+    # +name+ the name of the channel
+    def channel name
+      Http::ChannelContext.new(self, name)
+    end
+
+    # create a cleint context for acting on a client
+    # +id+ the id of the client
+    def client id
+      Http::ClientContext.new(self, id)
+    end
+
+    # the base URL based on the settings
+    def url
+      "#{@config.api_url}/apps/#{@config.app_id}"
+    end
+
+    # Create a default request object with the base URL
+    # +path+ extra path info
+    def request path
+      Http::Request.new("#{url}/#{path}", @config)
+    end
+
+    ####
+
+    # Connect to shove as a client in the current process
+    # +id+ optional shove id to supply
+    def connect id=nil
+      client = Client::Connection.new(self, id)
+      client.connect
+      client
+    end
+
+  end
+end

data/lib/shove/app_directory.rb

@@ -0,0 +1,104 @@
+
+module Shove
+
+  # Used for storing and accessing shove credentials
+  # from the command line utility
+  class AppDirectory
+
+    attr_accessor :apps, :app
+
+    def initialize io=STDIN, path=File.expand_path("~/.shove.yml")
+      @io = io
+      @path = path
+      @app = nil
+      @apps = {}
+      load!
+    end
+
+    def put app_id, app_key
+      @apps[app_id] = app_key
+      @app = app_id if @app.nil?
+      save
+    end
+
+    def key app_id
+      get_config(app_id)[:app_key]
+    end
+
+    def default= app_id
+      unless app_id.nil?
+        @app = app_id
+        save
+      end
+    end
+
+    def default
+      @app ? get_config(@app) : get_config
+    end
+
+    def get_config app_id=nil
+      config = ENV["SHOVE_ENV"] == "development" ? {
+        :api_url => "http://api.shove.dev:8080",
+        :ws_url => "ws://shove.dev:9000"
+      } : {}
+
+      if !@app.nil? && app_id.nil?
+        config[:app_id] = @app
+        config[:app_key] = key(@app)
+      elsif app_id.nil? || !@apps.key?(app_id)
+
+        puts "We need some information to continue"
+
+        if app_id.nil?
+          config[:app_id] = getinput "Enter App Id"
+        else
+          config[:app_id] = app_id
+        end
+
+        loop do
+          config[:app_key] = getinput "Enter App Key"
+
+          Shove.configure config
+          if Shove.valid?
+            puts "App Settings accepted.  Moving on..."
+            break
+          else
+            puts "App Settings invalid, please try again"
+          end
+        end
+
+        put config[:app_id], config[:app_key]
+      else
+        config[:app_id] = app_id
+        config[:app_key] = @apps[app_id]
+      end
+
+      config
+    end
+
+    private
+
+    def save
+      File.open(@path, "w") do |f|
+        f << {
+          "app" => @app,
+          "apps" => @apps
+        }.to_yaml
+      end
+    end
+
+    def getinput text
+      print "#{text}: "
+      @io.gets.strip
+    end
+
+    def load!
+      if FileTest.exist?(@path)
+        tmp = YAML.load_file(@path)
+        @app = tmp["app"]
+        @apps = tmp["apps"]
+      end
+    end
+
+  end
+end

data/lib/shove/client/callback.rb

@@ -0,0 +1,24 @@
+
+module Shove
+  module Client
+    # Represents a callback that can be canceled
+    class Callback
+      
+      def initialize group, block
+        @group = group
+        @block = block
+      end
+
+      def call *args
+        @block.call(*args)
+      end
+
+      def cancel
+        @group.delete self
+        @block = nil
+      end
+
+    end
+  end
+end
+  

data/lib/shove/client/channel.rb

@@ -0,0 +1,81 @@
+module Shove
+  module Client
+    class Channel
+
+      include Protocol
+
+      attr_accessor :name
+
+      # Create a new channel
+      # +name+ The name of the channel
+      def initialize name, conn
+        @conn = conn
+        @name = name
+        @callbacks = {}
+      end
+
+      # Bind a block to an event
+      # +event+ the event name
+      # +block+ the callback
+      def on event, &block
+        unless @callbacks.has_key?(event)
+          @callbacks[event] = []
+        end
+        result = Callback.new(@callbacks[event], block)
+        @callbacks[event] << result
+        result
+      end
+      
+      # Process a message for the channel
+      # +message+ the message in question
+      def process message
+        op = message["opcode"]
+        data = message["data"]
+
+        case op
+        when PUBLISH
+          emit("message", data)
+        when SUBSCRIBE_GRANTED
+          emit("subscribe")
+        when SUBSCRIBE_DENIED
+          emit("subscribe_denied")
+        when PUBLISH_DENIED
+          emit("publish_denied")
+        when PUBLISH_GRANTED
+          emit("publish_granted")
+        when UNSUBSCRIBE_COMPLETE
+          emit("unsubscribe")
+          @callbacks.clear
+        end
+
+      end
+
+      # publish a message on the channel
+      # +msg+ the message to publish.  It must implement to_s
+      def publish msg
+        @conn.send_data :opcode => PUBLISH, :channel => @name, :data => msg.to_s
+      end
+
+      # subscribe to the channel, by sending to the remote
+      def subscribe
+        @conn.send_data :opcode => SUBSCRIBE, :channel => @name
+      end
+
+      # unsubscribe from the channel
+      def unsubscribe
+        @conn.send_data :opcode => UNSUBSCRIBE, :channel => @name
+      end
+
+      private
+
+      def emit event, *args
+        if @callbacks.key?(event)
+          @callbacks[event].each do |cb|
+            cb.call(*args)
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/shove/client/connection.rb

@@ -0,0 +1,167 @@
+module Shove
+  module Client
+    class Connection
+
+      include Protocol
+
+      attr_accessor :id, :socket, :url
+
+      # Create a Publisher
+      # +app+ the app
+      def initialize app, id
+        @id = id
+        @app = app
+        @parser = Yajl::Parser.new(:symbolize_keys => true)
+        @config = app.config
+        @hosts = app.hosts
+        @channels = {}
+        @events = {}
+        @queue = []
+        @forcedc = false
+        @connected = false
+      end
+
+      def authorize app_key=nil
+        send_data :opcode => AUTHORIZE, :data => (app_key || @config.app_key)
+      end
+      
+      # Connect to the shove stream server
+      def connect
+
+        if @connected
+          return
+        end
+
+        @socket = EM::WebSocketClient.new(url)
+        @socket.onopen do
+          @connected = true
+          send_data :opcode => CONNECT, :data => @id
+          until @queue.empty? do
+            send_data @queue.shift
+          end
+        end
+        
+        @socket.onmessage do |m|
+          process Yajl::Parser.parse(m)
+        end
+
+        @socket.onclose do
+          @connected = false
+          unless @forcedc
+            reconnect
+          end
+        end
+      end
+      
+      # Disconnect form the server
+      def disconnect
+        @forcedc = true
+        @socket.disconnect
+      end
+
+      # Bind to events for a given channel.
+      # +channel+ the channel name to subscribe to
+      # +event+ the event name to bind to
+      # +block+ the block which is called when a message is received
+      def on event, &block
+        unless @events.key?(event)
+          @events[event] = []
+        end
+        @events[event] << block
+      end
+
+      # Fetch a channel
+      # +name+ the name of the channel
+      def channel name
+        unless @channels.key?(name)
+          @channels[name] = Channel.new(name, self)
+          if name != "direct"
+            @channels[name].subscribe
+          end
+        end
+        @channels[name]
+      end
+
+      def url
+        if @config.ws_url
+          @url = "#{@config.ws_url}/#{@config.app_id}"
+        else
+          if @hosts.empty?
+            raise "Error fetching hosts for app #{@app_id}"
+          end
+          @url = "ws://#{@hosts.first}.shove.io/#{@config.app_id}"
+        end
+        @url
+      end
+      
+      def send_data data
+        if @connected
+          @socket.send_data(Yajl::Encoder.encode(data))
+        else
+          @queue << data
+        end
+      end
+
+      protected
+
+      def reconnect
+        @reconnecting = true
+      end
+
+      def emit event, *args
+        if @events.key?(event)
+          @events[event].each do |block|
+            block.call(*args)
+          end
+        end
+      end
+
+      def process message
+
+        op = message["opcode"]
+        data = message["data"]
+        channel = message["channel"]
+
+        case op
+        when CONNECT_GRANTED
+          @id = data
+          emit "connect", @id
+        when CONNECT_DENIED
+          @id = data
+          emit "connect_denied", @id
+        when DISCONNECT
+          @closing = true
+          emit "disconnect", data
+        when ERROR
+          emit "error", data
+        when PUBLISH
+          channel = channel =~ /direct/ ? "direct" : channel
+          if @channels.key?(channel)
+            @channels[channel].process(message)
+          end
+        when SUBSCRIBE_GRANTED,
+             SUBSCRIBE_DENIED,
+             PUBLISH_GRANTED,
+             PUBLISH_DENIED,
+             UNSUBSCRIBE_COMPLETE
+          if @channels.key?(channel)
+            @channels[channel].process(message)
+          end
+        when DISCONNECT_COMPLETE
+          @closing = true
+          emit "disconnecting"
+        when AUTHORIZE_COMPLETE
+        else
+          #TODO: logger
+          puts "Unknown opcode"
+        end
+
+      end
+
+      def host
+        @hosts.first
+      end
+    
+    end
+  end
+end

data/lib/shove/http/channel_context.rb

@@ -0,0 +1,60 @@
+module Shove
+  module Http
+    class ChannelContext
+
+      attr_accessor :app, :channel
+
+      def initialize app, channel
+        @app = app
+        @channel = channel
+      end
+
+      # publish a message on the channel
+      # +message+ the message to publish
+      # +block+ called on response
+      def publish message, &block
+        if @channel == "*"
+          raise ShoveException.new("Cannot publish to *")
+        elsif message.size > 8096
+          raise ShoveException.new("Max message size is 8,096 bytes")
+        end
+        @app.request("publish?channel=#{@channel}").post(message, &block)
+      end
+
+      # grant subscription on the channel
+      # +client+ the client to grant
+      # +block+ called on response
+      def grant_subscribe client, &block
+        control_request("grant_subscribe", client, &block)
+      end
+
+      # grant publishing on the current channel
+      # +client+ the client to grant
+      # +block+ called on response
+      def grant_publish client, &block
+        control_request("grant_publish", client, &block)
+      end
+
+      # deny subscription on the channel
+      # +client+ the client to deny
+      # +block+ called on response
+      def deny_subscribe client, &block
+        control_request("deny_subscribe", client, &block)
+      end
+
+      # deny publishing on the channel
+      # +client+ the client to deny
+      # +block+ called on response
+      def deny_publish client, &block
+        control_request("deny_publish", client, &block)
+      end
+
+      private
+
+      def control_request action, client, &block
+        @app.request("#{action}?channel=#{@channel}&client=#{client}").post(&block)
+      end
+
+    end
+  end
+end

data/lib/shove/http/client_context.rb

@@ -0,0 +1,82 @@
+module Shove
+  module Http
+    class ClientContext
+
+      attr_accessor :app, :id
+
+      def initialize app, id
+        @app = app
+        @id = id
+      end
+
+      # publish a message directly to the client
+      # +message+ the message to publish
+      # +block+ called on response
+      def publish message, &block
+        @app.request("publish?channel=direct:#{@id}").post(message, &block)
+      end
+
+      # grant connection to client
+      # use this in cases where the app disallows any activity
+      # on newly established clients.
+      # +block+ called on response
+      def grant_connect &block
+        @app.request("grant_connect?client=#{@id}").post(&block)
+      end
+
+      # grant control to client
+      # turns the client into a full blown control client, allowing
+      # them to subscribe and publish to all channels, as well
+      # as grant and deny actions to other clients
+      # +block+ called on response
+      def grant_control &block
+        @app.request("grant_control?client=#{@id}").post(&block)
+      end
+
+      # grant connection to client
+      # use this to kick a client
+      # +block+ called on response
+      def deny_connect &block
+        @app.request("deny_connect?client=#{@id}").post(&block)
+      end
+
+      # grant connection to client
+      # use this to revoke power.  Clients will never have
+      # control by default, so this would always be called
+      # after calling grant_control
+      # +block+ called on response
+      def deny_control &block
+        @app.request("deny_control?client=#{@id}").post(&block)
+      end
+
+      # grant subscription to client
+      # +channel+ the channel to grant subscription on
+      # +block+ called on response
+      def grant_subscribe channel, &block
+        @app.request("grant_subscribe?channel=#{channel}&client=#{@id}").post(&block)
+      end
+
+      # grant publishing to client
+      # +channel+ the channel to grant publishing on
+      # +block+ called on response
+      def grant_publish channel, &block
+        @app.request("grant_publish?channel=#{channel}&client=#{@id}").post(&block)
+      end
+
+      # deny subscription to client
+      # +channel+ the channel to deny subscription on
+      # +block+ called on response
+      def deny_subscribe channel, &block
+        @app.request("deny_subscribe?channel=#{channel}&client=#{@id}").post(&block)
+      end
+
+      # deny publishing to client
+      # +channel+ the channel to deny publishing on
+      # +block+ called on response
+      def deny_publish channel, &block
+        @app.request("deny_publish?channel=#{channel}&client=#{@id}").post(&block)
+      end
+
+    end
+  end
+end

data/lib/shove/http/request.rb

@@ -0,0 +1,94 @@
+module Shove
+  module Http
+    class Request
+      
+      include EventMachine::HttpEncoding
+      
+      attr_accessor :url, :key, :headers
+      
+      def initialize url, config
+        @url = url
+        @key = config.app_key
+      end
+      
+      # HTTP Delete request
+      def delete &block
+        exec :delete, &block
+      end
+    
+      # HTTP Post request for new content
+      def post params={}, &block
+        exec :post, params, &block
+      end
+      
+      # HTTP Put request for updates
+      def put params={}, &block
+        exec :put, params, &block
+      end
+      
+      # HTTP Get request
+      def get &block
+        exec :get, &block
+      end
+      
+      def exec_sync method, params={}, &block
+        uri = URI.parse(url)
+
+        req = {
+          :post => Net::HTTP::Post,
+          :put => Net::HTTP::Put,
+          :get => Net::HTTP::Get,
+          :delete => Net::HTTP::Delete
+        }[method].new(uri.path + (uri.query ? "?#{uri.query}" : ""))
+        
+        req.basic_auth "", key
+
+        res = Net::HTTP.start(uri.host, uri.port) { |http|
+          http.request(req, normalize_body(params))
+        }
+
+        result = Response.new(res.code, res.body, res.code.to_i >= 400)
+        if block_given?
+          block.call(result)
+        end
+        
+        result
+      end
+      
+      def exec_async method, params={}, &block
+        http = EventMachine::HttpRequest.new(url).send(method, { 
+          :body => params,
+          :head => {
+            :authorization => ["", key]
+          } 
+        })
+        
+        # handle error
+        http.errback {
+          block.call(Response.new(http.response_header.status, http.response, true)) 
+        }
+        
+        # handle success
+        http.callback {
+          status = http.response_header.status
+          block.call(Response.new(status, http.response, status >= 400))
+        }
+      end
+      
+      # exec a HTTP request, and callback with
+      # a response via block
+      def exec method, params={}, &block
+        if EM.reactor_running?
+          exec_async(method, params, &block)
+        else
+          exec_sync(method, params, &block)
+        end
+      end
+      
+      def normalize_body(body)
+        body.is_a?(Hash) ? form_encode_body(body) : body
+      end
+      
+    end
+  end
+end