rhoconnect 3.0.0.beta1

data/lib/rhoconnect/dynamic_adapter.rb

@@ -0,0 +1,91 @@
+require 'json'
+require 'rest_client'
+require 'uri'
+
+module Rhoconnect
+  
+  class DynamicAdapter < SourceAdapter
+    attr_accessor :uri, :partition
+    
+    def initialize(source, partition=nil, uri=nil)
+      @source = source
+      @uri = uri || Rhoconnect.appserver
+      @partition = partition || @source.user_id
+      
+      if @uri
+        @uri = URI.parse(@uri)
+        user = @uri.user
+        @uri.user = nil
+        @uri = @uri.to_s 
+      end
+      
+      @token = Rhoconnect.api_token || user   
+      raise Exception.new("Please provide a :token or set it in uri") unless @token
+      super(source)
+    end
+    
+    def self.authenticate(login,password)
+      hsh = {:login => login, :password => password, :api_token => Rhoconnect.api_token}.to_json
+      headers = {:content_type => :json, :accept => :json}
+      RestClient.post "#{Rhoconnect.appserver}/rhoconnect/authenticate", hsh, headers
+    end
+    
+    def query(params=nil)
+      @result={}
+      @result = JSON.parse(send_objects('query',@source.name, @partition, params))
+    end
+    
+    def create(create_hash)
+      send_objects('create',@source.name, @partition, create_hash)
+    end
+    
+    def update(update_hash)
+      send_objects('update',@source.name, @partition, update_hash)
+    end
+    
+    def delete(delete_hash)
+      send_objects('delete',@source.name, @partition, delete_hash)
+    end
+    
+    #protected
+    
+    def validate_args(action, source_name, partition, obj = {}) # :nodoc:
+      raise Exception.new("Please set uri in your settings or through console") unless @uri
+      raise ArgumentError.new("Missing object id for #{obj.inspect}") if ['update','delete'].include? action and not obj.has_key?('id')
+      raise ArgumentError.new("Missing source_name.") if source_name.empty?
+      #raise ArgumentError.new("Missing partition for #{model}.") unless partition or partition.blank?
+    end
+
+    def send_objects(action, source_name, partition, obj = {}) # :nodoc:
+      validate_args(action, source_name, partition, obj)
+      process(:post, "/rhoconnect/#{action}", 
+        {
+          :resource => source_name,
+          :partition => partition,
+          :attributes => obj 
+        }
+      )
+    end
+        
+    def resource(path) # :nodoc:
+      RestClient::Resource.new(@uri)[path]
+    end
+
+    def process(method, path, payload = nil) # :nodoc:
+      headers = api_headers
+      payload  = payload.merge!(:api_token => @token).to_json
+      args     = [method, payload, headers].compact
+      response = resource(path).send(*args)
+      response
+    end
+
+    def api_headers   # :nodoc:
+      {
+        :content_type => :json, 
+        :accept => :json
+      }
+    end
+    
+  end
+  
+end

data/lib/rhoconnect/generator.rb

@@ -0,0 +1 @@
+require File.dirname(__FILE__) + '/../../generators/rhoconnect'

data/lib/rhoconnect/jobs/bulk_data_job.rb

@@ -0,0 +1,203 @@
+require 'zip/zip'
+require 'zlib'
+
+module Rhoconnect
+  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)
+          log "bulk_data.dbfile:  #{bulk_data.dbfile}"
+          create_hsql_data_file(bulk_data,ts) if Rhoconnect.blackberry_bulk_sync
+          lap_timer('create_hsql_data_file',timer)
+          log "finished bulk data process"
+          bulk_data.state = :completed
+          bulk_data.refresh_time = Time.now.to_i + Rhoconnect.bulk_sync_poll_interval
+        else
+          raise Exception.new("No bulk data found for #{params["data_name"]}")
+        end
+      rescue Exception => e
+        bulk_data.delete if bulk_data
+        log "Bulk data job raised: #{e.message}"
+        log e.backtrace.join("\n")
+        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
+    
+    # Loads data into fixed schema table based on source settings
+    def self.import_data_to_fixed_schema(db,source)
+      data = source.get_data(:md)
+      counter = {}
+      columns,qm = [],[]
+      create_table = ["\"object\" varchar(255) PRIMARY KEY"]
+      schema = JSON.parse(source.schema)
+      
+      db.transaction do |database|
+        # Create a table with columns specified by 'property' array in settings
+        schema['property'].each do |key,value|
+          create_table << "\"#{key}\" varchar default NULL" 
+          columns << key
+          qm << '?'
+        end
+        database.execute("CREATE TABLE #{source.name}(#{create_table.join(",")} );")
+
+        database.prepare("insert into #{source.name} (object,#{columns.join(',')}) values (?,#{qm.join(',')})") do |stmt|
+          data.each do |obj,row|
+            args = [obj]
+            columns.each { |col| args << row[col] }
+            # FIXME: The * is used to expand an array into individual arguments for 'execute' method.
+            # JRuby (1.6.0) won't work without asterisk, but MRI and 1.9.2 are both doing well! 
+            stmt.execute(*args) # FIXME: !!! 
+          end
+        end
+        
+        # Create indexes for specified columns in settings 'index'
+        schema['index'].each do |key,value|
+          val2 = ""
+          value.split(',').each do |col|
+            val2 += ',' if val2.length > 0
+            val2 += "\"#{col}\""
+          end
+          
+          database.execute("CREATE INDEX #{key} on #{source.name} (#{val2});")
+        end if schema['index']
+        
+        # Create unique indexes for specified columns in settings 'unique_index'
+        schema['unique_index'].each do |key,value|
+          val2 = ""
+          value.split(',').each do |col|
+            val2 += ',' if val2.length > 0
+            val2 += "\"#{col}\""
+          end
+        
+          database.execute("CREATE UNIQUE INDEX #{key} on #{source.name} (#{val2});")
+        end if schema['unique_index']
+      end
+    
+      return {}
+    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,sync_priority,partition,sync_type,source_attribs,metadata,schema,blob_attribs,associations) 
+          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.to_s,
+              s.sync_type.to_s,refs_to_s(ref[:refs]),s.get_value(:metadata),s.schema,s.blob_attribs,s.has_many)
+          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 = DBAdapter.instance.get_connection(bulk_data.dbfile)    
+      db.execute_batch(File.open(schema,'r').read)
+      
+      src_counter = 1
+      bulk_data.sources.members.sort.each do |source_name|
+        timer = start_timer("start importing sqlite data for #{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 = nil
+        if source.schema
+          source_attrib_refs = import_data_to_fixed_schema(db,source)
+        else
+          source_attrib_refs = import_data_to_object_values(db,source)
+        end
+        sources_refs[source_name] = 
+          {:source => source, :refs => source_attrib_refs}
+        lap_timer("finished importing sqlite data for #{source_name}",timer)
+      end
+      populate_sources_table(db,sources_refs)
+      
+      db.execute_batch(File.open(index,'r').read)
+      db.execute_batch("VACUUM;");
+      db.close
+      
+      compress("#{bulk_data.dbfile}.rzip",bulk_data.dbfile)
+      gzip_compress("#{bulk_data.dbfile}.gzip",bulk_data.dbfile)
+    end
+    
+    def self.create_hsql_data_file(bulk_data,ts)
+      schema,index,dbfile = get_file_args(bulk_data.name,ts)
+      hsql_file = dbfile + ".hsqldb"
+      cmd = ['java','-cp', File.join(File.expand_path(Rhoconnect.vendor_directory),'hsqldata.jar'),
+        'com.rhomobile.hsqldata.HsqlData', dbfile, hsql_file].join(" ")
+      log "Running hsqldata: #{cmd.to_s}"
+      raise Exception.new("Error running hsqldata") unless 
+        system(
+          'java','-cp', 
+          File.join(File.expand_path(Rhoconnect.vendor_directory),'hsqldata.jar'),
+          'com.rhomobile.hsqldata.HsqlData',
+          dbfile, hsql_file
+        )
+      gzip_compress("#{hsql_file}.data.gzip","#{hsql_file}.data")
+    end
+    
+    def self.get_file_args(bulk_data_name,ts)
+      schema = BulkData.schema_file
+      index = BulkData.index_file
+      dbfile = File.join(Rhoconnect.data_directory,bulk_data_name+'_'+ts+'.data')
+      [schema,index,dbfile]
+    end
+    
+    def self.compress(archive,file)
+      Zip::ZipFile.open(archive, 'w') do |zipfile|
+        zipfile.add(URI.escape(File.basename(file)),file)
+      end
+    end
+    
+    def self.gzip_compress(archive,file)
+      data = File.new(file, "rb")
+      File.open(archive, 'wb') do |f|
+        gz = Zlib::GzipWriter.new(f)
+        gz.write data.read
+        gz.close
+      end
+      data.close
+    end
+    
+  end
+end

data/lib/rhoconnect/jobs/ping_job.rb

@@ -0,0 +1,46 @@
+require 'rhoconnect/ping'
+
+module Rhoconnect
+  module PingJob
+    @queue = :ping
+    
+    # Perform a ping for all clients registered to a user
+    def self.perform(params)
+      user = User.load(params["user_id"])
+      device_pins = []
+      phone_ids   = []
+      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, 'phone_id' => client.phone_id)
+        send_push = false
+        if client.device_type and client.device_type.size > 0
+          if client.phone_id and client.phone_id.size > 0
+            unless phone_ids.include? client.phone_id   
+              phone_ids << client.phone_id
+              send_push = true
+            end
+          elsif client.device_pin and client.device_pin.size > 0
+            unless device_pins.include? client.device_pin   
+              device_pins << client.device_pin
+              send_push = true
+            end
+          else
+            log "Skipping ping for non-registered client_id '#{client_id}'..."
+            next
+          end
+          if send_push
+            klass = Object.const_get(camelize(client.device_type.downcase)) 
+            if klass
+              params['vibrate'] = params['vibrate'].to_s
+              klass.ping(params) 
+            end
+          else
+            log "Dropping ping request for client_id '#{client_id}' because it's already in user's device pin or phone_id list."
+          end
+        else
+          log "Skipping ping for non-registered client_id '#{client_id}'..."
+        end
+      end
+    end
+  end
+end

data/lib/rhoconnect/jobs/source_job.rb

@@ -0,0 +1,16 @@
+module Rhoconnect
+  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/rhoconnect/license.rb

@@ -0,0 +1,86 @@
+require 'openssl'
+
+module Rhoconnect
+  class LicenseException < RuntimeError; end
+  class LicenseSeatsExceededException < LicenseException; end
+  
+  class License
+    attr_reader :rhoconnect_version, :licensee, :seats, :issued
+    #attr_accessor :license
+
+    # ships with rhoconnect
+    RHO_PUBLICKEY = "99068e3a2708e6fe918252be8880eac539a1d2b2402651d75de5c7a2333a1cb2"
+    CLIENT_DOCKEY = 'rho_client_count'
+
+    def initialize
+      begin
+        if ENV['RHOCONNECT_LICENSE']
+          @license = ENV['RHOCONNECT_LICENSE']
+        elsif ENV['RHOSYNC_LICENSE']
+          @license = ENV['RHOSYNC_LICENSE']
+        else
+          settings = Rhoconnect.get_config(Rhoconnect.base_directory)[Rhoconnect.environment]
+          @license = IO.read(File.join(Rhoconnect.base_directory,settings[:licensefile])).strip
+        end
+        _decrypt
+      rescue Exception => e
+        log e.message
+        log 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 devices 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(',')
+      @rhoconnect_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/rhoconnect/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,timeout=0,raise_on_expire=false)
+    Store.lock(docname(doc),timeout,raise_on_expire) do
+      yield self
+    end
+  end
+end