rhosync 2.0.0.beta1

data/lib/rhosync/model.rb

@@ -0,0 +1,410 @@
+module Rhosync
+  # 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
+
+    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={})
+        return unless self.is_exist?(id)
+        populate_attributes(self.with_key(id),params)
+      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?
+        methods = model.methods
+        fields.each do |name,value|
+          model.send("#{name}=", value) if methods.include?(name.to_s)
+        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
+        @redis.smembers(@name).map { |v| @marshal.load(v) }
+      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/rhosync/ping/blackberry.rb

@@ -0,0 +1,55 @@
+require 'net/http'
+require 'uri'
+module Rhosync
+  class Blackberry
+    def self.ping(params)
+      begin
+        settings = get_config(Rhosync.base_directory)[Rhosync.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 << "show_popup=#{params['message']}\r\n" if params['message']
+      data << "vibrate=#{params['vibrate']}\r\n" if params['vibrate']
+      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/rhosync/ping/iphone.rb

@@ -0,0 +1,44 @@
+require 'socket'
+require 'openssl'
+module Rhosync
+  class Iphone
+    def self.ping(params)
+      settings = get_config(Rhosync.base_directory)[Rhosync.environment]
+      cert_file = File.join(Rhosync.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
+end

data/lib/rhosync/ping.rb

@@ -0,0 +1,2 @@
+require 'rhosync/ping/iphone'
+require 'rhosync/ping/blackberry'

data/lib/rhosync/read_state.rb

@@ -0,0 +1,27 @@
+module Rhosync  
+  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
+
+    private
+    def self.get_id(params)
+      "#{params[:app_id]}:#{params[:user_id]}:#{params[:source_name]}"
+    end
+  end
+end

data/lib/rhosync/server/views/index.erb

@@ -0,0 +1,12 @@
+<html>
+  <head>
+	<title>Rhosync Server</title>
+  </head>
+  <body>
+	<h3>Rhosync Server v<%=Rhosync::VERSION%> running...</h3>
+    <p><a href="/resque/">Resque</a></p>
+	<p><a href="/console/">Console</a></p>
+	<h3>Rhosync Info</h3>
+	TBD...
+  </body>
+</html>