rhosync 2.0.0.beta1

data/lib/rhosync/console/rhosync_api.rb

@@ -0,0 +1,102 @@
+require 'rest_client'
+
+module RhosyncApi
+  class << self
+    
+    def get_token(server,login,password)
+      res = RestClient.post("#{server}/login", 
+          {:login => login, :password => password}.to_json, :content_type => :json)
+      RestClient.post("#{server}/api/get_api_token",'',{:cookies => res.cookies})
+    end
+    
+    def list_users(server,app_name,token)
+      JSON.parse(RestClient.post("#{server}/api/list_users",
+        {:app_name => app_name, :api_token => token}.to_json, :content_type => :json).body)
+    end
+    
+    def create_user(server,app_name,token,login,password)
+      RestClient.post("#{server}/api/create_user",
+        {:app_name => app_name, :api_token => token,
+         :attributes => {:login => login, :password => password}}.to_json, 
+         :content_type => :json)
+    end  
+    
+    def delete_user(server,app_name,token,user_id)
+      RestClient.post("#{server}/api/delete_user",
+        {:app_name => app_name, :api_token => token, :user_id => user_id}.to_json, 
+         :content_type => :json)    
+    end
+  
+    def list_clients(server,app_name,token,user_id)
+      JSON.parse(RestClient.post("#{server}/api/list_clients", {:app_name => app_name, 
+        :api_token => token, :user_id => user_id}.to_json, :content_type => :json).body)
+    end
+    
+    def create_client(server,app_name,token,user_id)
+      RestClient.post("#{server}/api/create_client",
+        {:app_name => app_name, :api_token => token, :user_id => user_id}.to_json, 
+         :content_type => :json).body
+    end  
+    
+    def delete_client(server,app_name,token,user_id,client_id)
+      RestClient.post("#{server}/api/delete_client",
+        {:app_name => app_name, :api_token => token, :user_id => user_id, 
+         :client_id => client_id}.to_json, :content_type => :json)    
+    end
+
+    def get_client_params(server,app_name,token,client_id)
+      JSON.parse(RestClient.post("#{server}/api/get_client_params", {:app_name => app_name, 
+        :api_token => token, :client_id => client_id}.to_json, :content_type => :json).body)
+    end
+    
+    def list_sources(server,app_name,token,partition='all') 
+      JSON.parse(RestClient.post("#{server}/api/list_sources", {:app_name => app_name, 
+        :api_token => token, :partition_type => partition}.to_json, :content_type => :json).body)
+    end
+
+    def get_source_params(server,app_name,token,source_id)
+      JSON.parse(RestClient.post("#{server}/api/get_source_params", {:app_name => app_name, 
+        :api_token => token, :source_id => source_id}.to_json, :content_type => :json).body)
+    end
+    
+    def list_source_docs(server,app_name,token,source_id,user_id='*')
+      JSON.parse(RestClient.post("#{server}/api/list_source_docs", {:app_name => app_name, 
+        :api_token => token, :source_id => source_id, :user_id => user_id}.to_json, :content_type => :json).body)
+    end  
+      
+    def list_client_docs(server,app_name,token,source_id,client_id)
+      JSON.parse(RestClient.post("#{server}/api/list_client_docs", {:app_name => app_name, 
+        :api_token => token, :source_id => source_id, :client_id => client_id}.to_json, :content_type => :json).body)
+    end  
+        
+    def get_db_doc(server,token,doc,data_type='')
+      res = RestClient.post("#{server}/api/get_db_doc", 
+        {:api_token => token, :doc => doc, :data_type => data_type}.to_json, :content_type => :json).body
+      data_type=='' ? JSON.parse(res) : res
+    end
+
+    def set_db_doc(server,token,doc,data={},data_type='')
+      RestClient.post("#{server}/api/set_db_doc", 
+       {:api_token => token, :doc => doc, :data => data, :data_type => data_type}.to_json, :content_type => :json)
+    end
+          
+    def reset(server,token)
+      RestClient.post("#{server}/api/reset",
+        {:api_token => token}.to_json, :content_type => :json)
+    end
+    
+    def ping(server,token,user_id,params)
+      ping_params = {:api_token => token, :user_id => user_id}
+      [:message,:badge,:sound,:vibrate,:sources].each do |part|
+        ping_params.merge!(part => params[part]) if params[part]
+      end
+      RestClient.post("#{server}/api/ping",ping_params.to_json, :content_type => :json)
+    end
+
+    def get_license_info(server,token)
+      JSON.parse(RestClient.post("#{server}/api/get_license_info",
+        {:api_token => token}.to_json, :content_type => :json).body)
+    end
+    
+  end
+end

data/lib/rhosync/console/server.rb

@@ -0,0 +1,27 @@
+$:.unshift File.dirname(__FILE__)
+require 'rubygems'
+require 'sinatra/base'
+require 'erb'
+require 'json'
+require 'rhosync_api'
+
+module RhosyncConsole  
+  class << self
+    ROOT_DIR = File.dirname(File.expand_path(__FILE__)) unless defined? ROOT_DIR
+
+    def root_path(*args)
+      File.join(ROOT_DIR, *args)
+    end
+  end  
+
+  class Server < Sinatra::Base
+    set :views,  RhosyncConsole::root_path("app","views")
+    set :public, RhosyncConsole::root_path("app","public")
+    set :static, true    
+    use Rack::Session::Cookie
+  end
+end
+
+Dir[File.join(File.dirname(__FILE__),"app/**/*.rb")].each do |file|
+  require file
+end

data/lib/rhosync/credential.rb

@@ -0,0 +1,9 @@
+module Rhosync
+  class Credential
+    attr_accessor :login,:password,:token,:url
+    
+    def initialize(login,password,token,url)
+      @login,@password,@token,@url = login,password,token,url
+    end
+  end
+end

data/lib/rhosync/document.rb

@@ -0,0 +1,43 @@
+module Document
+  
+  # Store wrapper methods for document
+  def get_data(doctype,type=Hash)
+    Store.get_data(docname(doctype),type)
+  end
+  
+  def get_value(doctype)
+    Store.get_value(docname(doctype))
+  end
+  
+  def put_data(doctype,data,append=false)
+    Store.put_data(docname(doctype),data,append)
+  end
+  
+  def put_value(doctype,data)
+    Store.put_value(docname(doctype),data)
+  end
+  
+  def delete_data(doctype,data)
+    Store.delete_data(docname(doctype),data)
+  end
+  
+  def flash_data(doctype)
+    Store.flash_data(docname(doctype))
+  end
+  
+  def rename(srcdoctype,dstdoctype)
+    Store.rename(docname(srcdoctype),docname(dstdoctype))
+  end
+  
+  # Generate the fully-qualified docname
+  def docname(doctype)
+    "#{self.class.class_prefix(self.class)}:#{self.app_id}:#{self.doc_suffix(doctype)}"
+  end
+  
+  # Update count for a given document
+  def update_count(doctype,count)
+    name = docname(doctype)
+    value = Store.db.get(name).to_i + count
+    Store.db.set(name,value < 0 ? 0 : value) 
+  end
+end

data/lib/rhosync/indifferent_access.rb

@@ -0,0 +1,132 @@
+# 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.
+
+class HashWithIndifferentAccess < Hash
+  def initialize(constructor = {})
+    if constructor.is_a?(Hash)
+      super()
+      update(constructor)
+    # else
+    #   super(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?
+
+  # Fetches the value for the specified key, same as doing hash[key]
+  # def fetch(key, *extras)
+  #   super(convert_key(key), *extras)
+  # end
+
+  # Returns an array of the values at the specified indices:
+  #
+  #   hash = HashWithIndifferentAccess.new
+  #   hash[:a] = "x"
+  #   hash[:b] = "y"
+  #   hash.values_at("a", "b") # => ["x", "y"]
+  #
+  # def values_at(*indices)
+  #   indices.collect {|key| self[convert_key(key)]}
+  # end
+
+  # Returns an exact copy of the hash.
+  # def dup
+  #   HashWithIndifferentAccess.new(self)
+  # end
+
+  # Merges the instantized and the specified hashes together, giving precedence to the values from the second hash
+  # Does not overwrite the existing hash.
+  # def merge(hash)
+  #   self.dup.update(hash)
+  # end
+
+  # Removes a specified key from the hash.
+  # def delete(key)
+  #   super(convert_key(key))
+  # end
+
+  def stringify_keys!; self end
+  def symbolize_keys!; self end
+  def to_options!; self end
+
+  # Convert to a Hash with String keys.
+  # def to_hash
+  #   Hash.new(default).merge(self)
+  # end
+
+  protected
+    def convert_key(key)
+      key.kind_of?(Symbol) ? key.to_s : key
+    end
+
+    def convert_value(value)
+      # case value
+      # when Hash
+      #   value.with_indifferent_access
+      # when Array
+      #   value.collect { |e| e.is_a?(Hash) ? e.with_indifferent_access : e }
+      # else
+        value
+      # end
+    end
+end
+
+class Hash
+public
+    def with_indifferent_access
+      hash = HashWithIndifferentAccess.new(self)
+      hash.default = self.default
+      hash
+    end
+end

data/lib/rhosync/jobs/bulk_data_job.rb

@@ -0,0 +1,104 @@
+require 'sqlite3'
+
+module Rhosync
+  module BulkDataJob
+    @queue = :bulk_data
+    
+    def self.perform(params)
+      bulk_data = nil
+      begin
+        bulk_data = BulkData.load(params["data_name"]) if BulkData.is_exist?(params["data_name"])
+        if bulk_data
+          timer = start_timer('starting bulk data process')
+          bulk_data.process_sources
+          timer = lap_timer('process_sources',timer)
+          ts = Time.now.to_i.to_s
+          create_sqlite_data_file(bulk_data,ts)
+          timer = lap_timer('create_sqlite_data_file',timer)
+          create_hsql_data_file(bulk_data,ts) if Rhosync.blackberry_bulk_sync
+          timer = lap_timer('create_hsql_data_file',timer)
+          bulk_data.state = :completed
+        else
+          raise Exception.new("No bulk data found for #{params["data_name"]}")
+        end
+      rescue Exception => e
+        bulk_data.delete if bulk_data
+        raise e
+      end
+    end
+    
+    def self.import_data_to_object_values(db,source)
+      data = source.get_data(:md)
+      counter = {}
+      db.transaction do |database|
+        database.prepare("insert into object_values 
+          (source_id,attrib,object,value) values (?,?,?,?)") do |stmt|
+          data.each do |object_id,object|
+            object.each do |attrib,value|
+              counter[attrib] = counter[attrib] ? counter[attrib] + 1 : 1
+              stmt.execute(source.source_id.to_i,attrib,object_id,value)
+            end
+          end
+        end
+      end
+      counter
+    end
+     
+    def self.refs_to_s(refs)
+      str = ''
+      refs.sort.each do |name,value|
+        str << "#{name},#{value},"
+      end
+      str[0..-2]
+    end
+    
+    def self.populate_sources_table(db,sources_refs) 
+      db.transaction do |database|
+        database.prepare("insert into sources
+          (source_id,name,priority,partition,sync_type,source_attribs) 
+          values (?,?,?,?,?,?)") do |stmt|
+          sources_refs.each do |source_name,ref|
+            s = ref[:source]
+            stmt.execute(s.source_id,s.name,s.priority,s.partition_type,
+              s.sync_type,refs_to_s(ref[:refs]))
+          end
+        end
+      end
+    end  
+    
+    def self.create_sqlite_data_file(bulk_data,ts)
+      sources_refs = {}
+      schema,index,bulk_data.dbfile = get_file_args(bulk_data.name,ts)
+      FileUtils.mkdir_p(File.dirname(bulk_data.dbfile))
+      db = SQLite3::Database.new(bulk_data.dbfile)
+      db.execute_batch(File.open(schema,'r').read)
+      src_counter = 1
+      bulk_data.sources.members.sort.each do |source_name|
+        source = Source.load(source_name,{:app_id => bulk_data.app_id,
+          :user_id => bulk_data.user_id})
+        source.source_id = src_counter
+        src_counter += 1
+        source_attrib_refs = import_data_to_object_values(db,source)
+        sources_refs[source_name] = 
+          {:source => source, :refs => source_attrib_refs}
+      end
+      populate_sources_table(db,sources_refs)
+      db.execute_batch(File.open(index,'r').read)
+    end
+    
+    def self.create_hsql_data_file(bulk_data,ts)
+      schema,index,dbfile = get_file_args(bulk_data.name,ts)
+      hsql_file = dbfile + ".hsqldb"
+      raise Exception.new("Error running hsqldata") unless 
+        system('java','-cp', File.join(File.dirname(__FILE__),'..','..','..','vendor','hsqldata.jar'),
+        'com.rhomobile.hsqldata.HsqlData', dbfile, hsql_file, schema, index)
+    end
+    
+    def self.get_file_args(bulk_data_name,ts)
+      schema = BulkData.schema_file
+      index = BulkData.index_file
+      dbfile = File.join(Rhosync.data_directory,bulk_data_name+'_'+ts+'.data')
+      [schema,index,dbfile]
+    end
+  end
+end

data/lib/rhosync/jobs/ping_job.rb

@@ -0,0 +1,19 @@
+require 'rhosync/ping'
+
+module Rhosync
+  module PingJob
+    @queue = :ping
+    
+    # Perform a ping for all clients registered to a user
+    def self.perform(params)
+      user = User.load(params["user_id"])
+      user.clients.members.each do |client_id|
+        client = Client.load(client_id,{:source_name => '*'})
+        params.merge!('device_port' => client.device_port,
+          'device_pin' => client.device_pin)        
+        klass = Object.const_get(camelize(client.device_type.downcase))
+        klass.ping(params) if klass
+      end
+    end
+  end
+end

data/lib/rhosync/jobs/source_job.rb

@@ -0,0 +1,16 @@
+module Rhosync
+  class SourceJob
+    class << self
+      attr_accessor :queue
+    end
+    
+    def self.perform(job_type,source_id,app_id,user_id,client_id,params)
+      source = Source.load(source_id,{:app_id => app_id,:user_id => user_id})
+      source_sync = SourceSync.new(source)
+      case job_type.to_sym
+      when :query then source_sync.do_query(params)
+      when :cud then source_sync.do_cud(client_id)
+      end    
+    end
+  end
+end

data/lib/rhosync/license.rb

@@ -0,0 +1,79 @@
+require 'openssl'
+
+module Rhosync
+  class LicenseException < RuntimeError; end
+  class LicenseSeatsExceededException < LicenseException; end
+  
+  class License
+    attr_reader :rhosync_version, :licensee, :seats, :issued
+    #attr_accessor :license
+
+    # ships with rhosync
+    RHO_PUBLICKEY = "99068e3a2708e6fe918252be8880eac539a1d2b2402651d75de5c7a2333a1cb2"
+    CLIENT_DOCKEY = 'rho_client_count'
+
+    def initialize
+      begin
+        settings = Rhosync.get_config(Rhosync.base_directory)[Rhosync.environment]
+        @license = IO.read(File.join(Rhosync.base_directory,settings[:licensefile])).strip
+        _decrypt
+      rescue Exception => e
+        #puts e.backtrace.join('\n')
+        raise LicenseException.new("Error verifying license.")
+      end
+    end
+    
+    def check_and_use_seat
+      incr = false
+      Store.lock(CLIENT_DOCKEY) do
+        current = Store.get_value(CLIENT_DOCKEY)
+        current = current ? current.to_i : 0
+        if current < self.seats
+          Store.put_value CLIENT_DOCKEY, current + 1
+          incr = true
+        end
+      end
+      unless incr
+        msg = "WARNING: Maximum # of clients exceeded for this license."
+        log msg; raise LicenseSeatsExceededException.new(msg)
+      end
+    end
+    
+    def free_seat
+      Store.lock(CLIENT_DOCKEY) do
+        current = Store.get_value(CLIENT_DOCKEY)
+        current = current ? current.to_i : 0
+        if current > 0
+          Store.put_value CLIENT_DOCKEY, current - 1
+        end
+      end
+    end
+    
+    def available
+      current = Store.get_value(CLIENT_DOCKEY)
+      current = current ? current.to_i : 0
+      available = self.seats - current
+      available > 0 ? available : 0
+    end
+      
+    private
+
+    def _decrypt
+      cipher = OpenSSL::Cipher::Cipher.new("aes-256-ecb")
+      cipher.key = _extract_str(RHO_PUBLICKEY)
+      cipher.decrypt
+
+      decrypted = cipher.update(_extract_str(@license))
+      decrypted << cipher.final
+      parts = decrypted.split(',')
+      @rhosync_version = parts[0].strip
+      @licensee = parts[1].strip
+      @seats = parts[2].strip.to_i
+      @issued = parts[3].strip
+    end
+
+    def _extract_str(str)
+      str.gsub(/(..)/){|h| h.hex.chr}
+    end
+  end
+end

data/lib/rhosync/lock_ops.rb

@@ -0,0 +1,11 @@
+
+# Collection of methods for locking shared
+# source documents when source_sync and client_sync
+# need to access them
+module LockOps
+  def lock(doc)
+    Store.lock(docname(doc)) do
+      yield self
+    end
+  end
+end