rhoconnect 3.0.0.beta1

data/lib/rhoconnect/model.rb

@@ -0,0 +1,414 @@
+module Rhoconnect
+  # Taken from http://github.com/voloko/redis-model
+  #
+  # Simple models for redis-rb.
+  
+  class Model
+    attr_accessor :id
+  
+    def initialize(id=nil)
+      self.id = id
+    end
+  
+    def redis #:nodoc:
+      self.class.redis
+    end
+  
+    # Issues delete commands for all defined fields
+    def delete(name = nil)
+      if name
+        redis.del field_key(name.to_s)
+      else
+        self.class.fields.each do |field|
+          redis.del field_key(field[:name])
+        end
+      end
+    end
+  
+    def field_key(name) #:nodoc:
+      self.class._field_key(prefix,id,name)
+    end
+
+    # Increment the specified integer field by 1 or the
+    # specified amount.
+    def increment!(name,amount=1)
+      raise ArgumentError, "Only integer fields can be incremented." unless self.class.fields.include?({:name => name.to_s, :type => :integer})
+      redis.incr(field_key(name), amount)
+    end
+  
+    # Decrement the specified integer field by 1 or the
+    # specified amount.
+    def decrement!(name,amount=1)
+      raise ArgumentError, "Only integer fields can be decremented." unless self.class.fields.include?({:name => name.to_s, :type => :integer})
+      redis.decr(field_key(name), amount)
+    end
+    
+    def next_id #:nodoc:
+      redis.incr "sequence:#{self.prefix}:id"
+    end
+  
+    def self.is_exist?(id)
+      !redis.get(self._field_key(self._prefix,id,'rho__id')).nil?
+    end
+  
+    def to_array
+      res = []
+      self.class.fields.each do |field|
+        res << field.merge!(:value => send(field[:name].to_sym))
+      end
+      res
+    end
+
+    # TODO: not used anymore
+    # def update(attribs)
+    #   self.class.fields.each do |field|
+    #     if field[:name] != 'name' and field[:name] != 'rho__id'
+    #       redis.del field_key(field[:name]) 
+    #     end  
+    #   end    
+    #   self.class.populate_attributes(self,attribs)
+    # end
+      
+  protected
+    def prefix #:nodoc:
+      @prefix ||= self.class.prefix || self.class.class_prefix(self.class)
+    end
+ 
+    class << self
+      # Defaults to model_name.dasherize
+      attr_accessor :prefix
+      attr_accessor :validates_presence
+      
+      def _prefix
+        class_prefix(self)
+      end
+  
+      def _field_key(p,i,n) #:nodoc:
+        "#{p}:#{i}:#{n}"
+      end
+
+      def class_prefix(classname)
+        classname.to_s.
+          sub(%r{(.*::)}, '').
+          gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+          gsub(/([a-z\d])([A-Z])/,'\1_\2').
+          downcase
+      end
+  
+      # Creates new model instance with new uniqid
+      # NOTE: "sequence:model_name:id" key is used
+      def create(params = {}, attributes = {})
+        raise ArgumentError.new("Record already exists for '#{params[:id]}'") if self.is_exist?(params[:id])
+        if self.validates_presence
+          self.validates_presence.each do |field|
+            raise ArgumentError.new("Missing required field '#{field}'") unless params[field]
+          end
+        end
+        o = self.new
+        o.id = params[:id].nil? ? o.next_id : params[:id]
+        params[:rho__id] = params[:id]
+        populate_model(o,params)
+        populate_attributes(o,attributes)
+      end
+      
+      def load(id, params={})
+        populate_attributes(self.with_key(id),params) if self.is_exist?(id)
+      end
+      
+      def populate_attributes(obj,attribs)
+        attribs.each do |attrib,value|
+          obj.send "#{attrib.to_s}=".to_sym, value
+        end
+        obj
+      end
+      
+      def validates_presence_of(*names)
+        self.validates_presence ||= []
+        names.each do |name|
+          self.validates_presence << name
+        end
+      end
+  
+      # Creates new model instance with given id
+      alias_method :with_key, :new
+      alias_method :with_next_key, :create
+  
+      # Defines marshaled rw accessor for redis string value
+      def field(name, type = :string)
+        if @fields.nil?
+          @fields = []
+          field :rho__id, :string
+        end        
+        type = type.to_sym
+        type = :integer if type == :int
+      
+        class_name = marshal_class_name(name, type)
+      
+        fields << {:name => name.to_s, :type => type}
+        if type == :string
+          class_eval "def #{name}; @#{name} ||= redis[field_key('#{name}')]; end"
+          class_eval "def #{name}=(value); @#{name} = redis[field_key('#{name}')] = value; end"
+        else
+          class_eval "def #{name}; @#{name} ||= Marshal::#{class_name}.load(redis[field_key('#{name}')]); end"
+          class_eval "def #{name}=(value); @#{name} = value; redis[field_key('#{name}')] = Marshal::#{class_name}.dump(value); end"
+        end
+      end
+      alias_method :value, :field
+        
+      # Defines accessor for redis list
+      def list(name, type = :string)
+        class_name = marshal_class_name(name, type)
+      
+        fields << {:name => name.to_s, :type => :list}
+        class_eval "def #{name}; @#{name} ||= ListProxy.new(self.redis, field_key('#{name}'), Marshal::#{class_name}); end"
+        eval_writer(name)
+      end
+  
+      # Defines accessor for redis set
+      def set(name, type = :string)
+        class_name = marshal_class_name(name, type)
+      
+        fields << {:name => name.to_s, :type => :set}
+        class_eval "def #{name}; @#{name} ||= SetProxy.new(self.redis, field_key('#{name}'), Marshal::#{class_name}); end"
+        eval_writer(name)
+      end
+    
+      def marshal_class_name(name, type)
+        Marshal::TYPES[type] or raise ArgumentError.new("Unknown type #{type} for field #{name}")
+      end
+  
+      # Redefine this to change connection options
+      def redis
+        @@redis ||= Store.db
+      end
+    
+      def fields #:nodoc:
+        @fields ||= []
+      end
+ 
+    protected
+      def eval_writer(name) #:nodoc:
+        class_eval <<-END
+  def #{name}=(value)
+  field = self.#{name};
+  if value.respond_to?(:each)
+  value.each {|v| field << v}
+  else
+  field << v
+  end
+  end
+  END
+      end
+  
+      def populate_model(model, fields)
+        return model if fields.empty?
+        fields.each do |name,value|
+          model.send("#{name}=", value) if model.respond_to?(name)
+        end
+        model
+      end
+    end
+  
+    module Marshal
+      TYPES = {
+        :string => 'String',
+        :integer => 'Integer',
+        :float => 'Float',
+        :datetime => 'DateTime',
+        :json => 'JSON',
+      }
+ 
+      class String
+        def self.dump(v)
+          v
+        end
+ 
+        def self.load(v)
+          v
+        end
+      end
+ 
+      class Integer
+        def self.dump(v)
+          v.to_s
+        end
+ 
+        def self.load(v)
+          v && v.to_i
+        end
+      end
+ 
+      class Float
+        def self.dump(v)
+          v.to_s
+        end
+ 
+        def self.load(v)
+          v && v.to_f
+        end
+      end
+ 
+      class DateTime
+        def self.dump(v)
+          v.strftime('%FT%T%z')
+        end
+ 
+        def self.load(v)
+          v && ::DateTime.strptime(v, '%FT%T%z')
+        end
+      end
+ 
+      class JSON
+        def self.dump(v)
+          ::JSON.dump(v)
+        end
+ 
+        def self.load(v)
+          v && ::JSON.load(v)
+        end
+      end
+    end
+  
+  
+  
+    class FieldProxy #:nodoc
+      def initialize(redis, name, marshal)
+        @redis = redis
+        @name = name
+        @marshal = marshal
+      end
+ 
+      # def method_missing(method, *argv)
+      #   translated_method = translate_method_name(method)
+      #   raise NoMethodError.new("Method '#{method}' is not defined") unless translated_method
+      #   @redis.send translated_method, @name, *argv
+      # end
+      #  
+      # protected
+      #   def translate_method_name(m)
+      #     m
+      #   end
+    end
+ 
+ 
+ 
+    class ListProxy < FieldProxy #:nodoc:
+      def <<(v)
+        @redis.rpush @name, @marshal.dump(v)
+      end
+      alias_method :push_tail, :<<
+    
+      def push_head(v)
+        @redis.lpush @name, @marshal.dump(v)
+      end
+    
+      def pop_tail
+        @marshal.load(@redis.rpop(@name))
+      end
+    
+      def pop_head
+        @marshal.load(@redis.lpop(@name))
+      end
+    
+      def [](from, to = nil)
+        if to.nil?
+          @marshal.load(@redis.lindex(@name, from))
+        else
+          @redis.lrange(@name, from, to).map! { |v| @marshal.load(v) }
+        end
+      end
+      alias_method :range, :[]
+    
+      def []=(index, v)
+        @redis.lset(@name, index, @marshal.dump(v))
+      end
+      alias_method :set, :[]=
+    
+      def include?(v)
+        @redis.exists(@name, @marshal.dump(v))
+      end
+    
+      def remove(count, v)
+        @redis.lrem(@name, count, @marshal.dump(v))
+      end
+    
+      # def length
+      #   @redis.llen(@name)
+      # end
+      #     
+      # def trim(from, to)
+      #   @redis.ltrim(@name, from, to)
+      # end
+      #     
+      # def to_s
+      #   range(0, 100).join(', ')
+      # end
+      #  
+    # protected
+    #   def translate_method_name(m)
+    #     COMMANDS[m]
+    #   end
+    end
+ 
+ 
+ 
+    class SetProxy < FieldProxy #:nodoc:
+      # COMMANDS = {
+      #   :intersect_store => "sinterstore",
+      #   :union_store => "sunionstore",
+      #   :diff_store => "sdiffstore",
+      #   :move => "smove",
+      # }
+    
+      def <<(v)
+        @redis.sadd @name, @marshal.dump(v)
+      end
+      alias_method :add, :<<
+    
+      def delete(v)
+        @redis.srem @name, @marshal.dump(v)
+      end
+      alias_method :remove, :delete
+    
+      def include?(v)
+        @redis.sismember @name, @marshal.dump(v)
+      end
+      alias_method :has_key?, :include?
+      alias_method :member?, :include?
+    
+      def members
+        members = @redis.smembers(@name)
+        if members
+          members.map { |v| @marshal.load(v) }
+        else 
+          []
+        end
+      end
+    
+      def intersect(*keys)
+        @redis.sinter(@name, *keys).map { |v| @marshal.load(v) }
+      end
+    
+      def union(*keys)
+        @redis.sunion(@name, *keys).map { |v| @marshal.load(v) }
+      end
+    
+      def diff(*keys)
+        @redis.sdiff(@name, *keys).map { |v| @marshal.load(v) }
+      end
+    
+        # def length
+        #   @redis.llen(@name)
+        # end
+        #     
+        # def to_s
+        #   members.join(', ')
+        # end
+        #  
+    # protected
+    #   def translate_method_name(m)
+    #     COMMANDS[m]
+    #   end
+    end
+  end
+end

data/lib/rhoconnect/ping/android.rb

@@ -0,0 +1,56 @@
+require 'rest_client'
+
+module Rhoconnect
+  class Android
+    class StaleAuthToken < Exception; end
+    class InvalidAuthToken < Exception; end
+    class AndroidPingError < Exception; end
+    
+    def self.ping(params)
+      begin
+        settings = get_config(Rhoconnect.base_directory)[Rhoconnect.environment]
+        authtoken = settings[:authtoken]
+              
+        RestClient.post(
+          'https://android.apis.google.com/c2dm/send', c2d_message(params), 
+          :authorization => "GoogleLogin auth=#{authtoken}"
+        ) do |response, request, result, &block|
+          # return exceptions based on response code & body
+          case response.code
+          when 200
+            # TODO: Automate authtoken updates
+            if response[:update_client_auth]
+              raise StaleAuthToken.new(
+                "Stale auth token, please update :authtoken: in settings.yml."
+              )
+            # body will contain the exception class
+            elsif response.body =~ /^Error=(.*)$/
+              raise AndroidPingError.new("Android ping error: #{$1 || ''}")
+            else
+              response.return!(request, result, &block)
+            end
+          when 401, 403
+            raise InvalidAuthToken.new("Invalid auth token, please update :authtoken: in settings.yml.")
+          end
+        end
+      rescue Exception => error
+        log error
+        log error.backtrace.join("\n")
+        raise error
+      end
+    end
+    
+    def self.c2d_message(params)
+      params.reject! {|k,v| v.nil? || v.length == 0}
+      data = {}
+      data['registration_id'] = params['device_pin']
+      data['collapse_key'] = (rand * 100000000).to_i.to_s
+      data['data.do_sync'] = params['sources'] ? params['sources'].join(',') : ''
+      data['data.alert'] = params['message'] if params['message']
+      data['data.vibrate'] = params['vibrate'] if params['vibrate']
+      data['data.sound'] = params['sound'] if params['sound']
+      data['data.phone_id'] = params['phone_id'] if params['phone_id']
+      data
+    end
+  end
+end

data/lib/rhoconnect/ping/apple.rb

@@ -0,0 +1,52 @@
+require 'socket'
+require 'openssl'
+module Rhoconnect
+  class Apple
+    def self.ping(params)
+      settings = get_config(Rhoconnect.base_directory)[Rhoconnect.environment]
+      cert_file = File.join(Rhoconnect.base_directory,settings[:iphonecertfile])
+      cert = File.read(cert_file) if File.exists?(cert_file)
+    	passphrase = settings[:iphonepassphrase]
+    	host = settings[:iphoneserver]
+    	port = settings[:iphoneport] 
+      begin
+        ssl_ctx = OpenSSL::SSL::SSLContext.new
+    		ssl_ctx.key = OpenSSL::PKey::RSA.new(cert, passphrase)
+    		ssl_ctx.cert = OpenSSL::X509::Certificate.new(cert)
+
+    		socket = TCPSocket.new(host, port)
+    		ssl_socket = OpenSSL::SSL::SSLSocket.new(socket, ssl_ctx)
+    		ssl_socket.sync = true
+    		ssl_socket.connect
+
+    		ssl_socket.write(apn_message(params))
+    		ssl_socket.close
+    		socket.close
+  		rescue SocketError => error
+  		  log "Error while sending ping: #{error}"
+  		  raise error
+  		end
+    end
+
+    # Generates APNS package
+  	def self.apn_message(params)
+  		data = {}
+  		data['aps'] = {}
+  		data['aps']['alert'] = params['message'] if params['message'] 
+  		data['aps']['badge'] = params['badge'].to_i if params['badge']
+  		data['aps']['sound'] = params['sound'] if params['sound']
+  		data['aps']['vibrate'] = params['vibrate'] if params['vibrate']
+  		data['do_sync'] = params['sources'] if params['sources']
+  		json = data.to_json
+  		"\0\0 #{[params['device_pin'].delete(' ')].pack('H*')}\0#{json.length.chr}#{json}"
+  	end
+  end
+  
+  # Deprecated - use Apple instead
+  class Iphone < Apple    
+    def self.ping(params)
+      log "DEPRECATION WARNING: 'iphone' is a deprecated device_type, use 'apple' instead"
+      super(params)
+    end
+  end
+end

data/lib/rhoconnect/ping/blackberry.rb

@@ -0,0 +1,56 @@
+require 'net/http'
+require 'uri'
+module Rhoconnect
+  class Blackberry
+    def self.ping(params)
+      begin
+        settings = get_config(Rhoconnect.base_directory)[Rhoconnect.environment]
+        host = settings[:mdsserver]
+      	port = settings[:mdsserverport]
+        
+        headers = { "X-WAP-APPLICATION-ID" => "/",
+                    "X-RIM-PUSH-DEST-PORT" => params['device_port'],
+                    "CONTENT-TYPE" => 'multipart/related; type="application/xml"; boundary=asdlfkjiurwghasf'}
+                    
+        Net::HTTP.new(host,port).start do |http|
+          request = Net::HTTP::Post.new('/pap',headers)
+          request.body = pap_message(params)
+          http.request(request)
+        end
+
+      rescue Exception => error
+        log "Error while sending ping: #{error}"
+        raise error
+      end
+    end
+    
+    def self.pap_message(params)
+      data = "do_sync=" + (params['sources'] ? params['sources'].join(',') : "") + "\r\n"
+      data << "alert=#{params['message']}\r\n" if params['message']
+      data << "vibrate=#{params['vibrate']}\r\n" if params['vibrate']
+      data << "sound=#{params['sound']}\r\n" if params['sound']
+      post_body = <<-DESC
+--asdlfkjiurwghasf
+Content-Type: application/xml; charset=UTF-8
+
+<?xml version="1.0"?>
+<!DOCTYPE pap PUBLIC "-//WAPFORUM//DTD PAP 2.0//EN" 
+  "http://www.wapforum.org/DTD/pap_2.0.dtd" 
+  [<?wap-pap-ver supported-versions="2.0"?>]>
+<pap>
+<push-message push-id="pushID:#{(rand * 100000000).to_i.to_s}" ppg-notify-requested-to="http://localhost:7778">
+
+<address address-value="WAPPUSH=#{params['device_pin'].to_i.to_s(base=16).upcase}%3A100/TYPE=USER@rim.net"/>
+<quality-of-service delivery-method="preferconfirmed"/>
+</push-message>
+</pap>
+--asdlfkjiurwghasf
+Content-Type: text/plain
+
+#{data}
+--asdlfkjiurwghasf--
+DESC
+      post_body.gsub!(/\n/,"\r\n")
+    end
+  end
+end

data/lib/rhoconnect/ping.rb

@@ -0,0 +1,3 @@
+require 'rhoconnect/ping/android'
+require 'rhoconnect/ping/apple'
+require 'rhoconnect/ping/blackberry'

data/lib/rhoconnect/read_state.rb

@@ -0,0 +1,31 @@
+module Rhoconnect  
+  class ReadState < Model
+    field :refresh_time, :integer
+  
+    def self.create(fields)
+      fields[:id] = get_id(fields)
+      fields.delete(:app_id)
+      fields.delete(:user_id)
+      fields.delete(:source_name)
+      fields[:refresh_time] ||= Time.now.to_i
+      super(fields,{})
+    end
+  
+    def self.load(params)
+      super(get_id(params),{})
+    end
+    
+    def self.delete(app_id)
+      Store.flash_data("#{class_prefix(self)}:#{app_id}:*")
+    end
+    
+    def self.delete_user(params)
+      Store.flash_data("#{class_prefix(self)}:#{params[:app_id]}:#{params[:user_id]}:#{params[:source_name]}:*")
+    end
+
+    private
+    def self.get_id(params)
+      "#{params[:app_id]}:#{params[:user_id]}:#{params[:source_name]}"
+    end
+  end
+end

data/lib/rhoconnect/rho_indifferent_access.rb

@@ -0,0 +1,88 @@
+# This class has dubious semantics and we only have it so that
+# people can write params[:key] instead of params['key']
+# and they get the same value for both keys.
+
+module Rhoconnect
+  class RhoHashWithIndifferentAccess < Hash
+    def initialize(constructor = {})
+      if constructor.is_a?(Hash)
+        super()
+        update(constructor)
+      end
+    end
+
+    def default(key = nil)
+      if key.is_a?(Symbol) && include?(key = key.to_s)
+        self[key]
+      else
+        super
+      end
+    end
+
+    alias_method :regular_writer, :[]= #unless method_defined?(:regular_writer)
+    alias_method :regular_update, :update #unless method_defined?(:regular_update)
+
+    # Assigns a new value to the hash:
+    #
+    #   hash = HashWithIndifferentAccess.new
+    #   hash[:key] = "value"
+    #
+    def []=(key, value)
+      regular_writer(convert_key(key), convert_value(value))
+    end
+
+    # Updates the instantized hash with values from the second:
+    # 
+    #   hash_1 = HashWithIndifferentAccess.new
+    #   hash_1[:key] = "value"
+    # 
+    #   hash_2 = HashWithIndifferentAccess.new
+    #   hash_2[:key] = "New Value!"
+    # 
+    #   hash_1.update(hash_2) # => {"key"=>"New Value!"}
+    # 
+    def update(other_hash)
+      other_hash.each_pair { |key, value| regular_writer(convert_key(key), convert_value(value)) }
+      self
+    end
+
+    alias_method :merge!, :update
+
+    # Checks the hash for a key matching the argument passed in:
+    #
+    #   hash = HashWithIndifferentAccess.new
+    #   hash["key"] = "value"
+    #   hash.key? :key  # => true
+    #   hash.key? "key" # => true
+    #
+    def key?(key)
+      super(convert_key(key))
+    end
+
+    alias_method :include?, :key?
+    alias_method :has_key?, :key?
+    alias_method :member?, :key?
+
+    def stringify_keys!; self end
+    def symbolize_keys!; self end
+    def to_options!; self end
+
+    protected
+      def convert_key(key)
+        key.kind_of?(Symbol) ? key.to_s : key
+      end
+
+      def convert_value(value)
+        value
+      end
+  end
+end
+
+class Hash  
+  public
+  def with_indifferent_access
+    hash = Rhoconnect::RhoHashWithIndifferentAccess.new(self)
+    hash.default = self.default
+    hash
+  end
+end