rhoconnect 3.0.0.beta1

data/lib/rhoconnect/x_domain_session_wrapper.rb

@@ -0,0 +1,53 @@
+require "cgi"
+
+class XDomainSessionWrapper
+  def initialize(app, opts={})
+    @app = app
+    @session_cookie = opts[:session_cookie] || 'rhoconnect_session'
+    @api_uri_regexp = opts[:api_uri_regexp] || /\A\/api\/application/
+    @login_uri_regexp = opts[:login_uri_regexp] || /\A\/api\/application\/clientlogin/
+    yield self if block_given?
+  end
+
+  def is_sync_protocol(env)
+    # if it is rhoconnect protocol URI
+    @api_uri_regexp.match(env['PATH_INFO'])
+  end
+
+  def call(env)
+    if is_sync_protocol(env)
+      env['HTTP_COOKIE'] = env['HTTP_COOKIE'] || CGI.unescape(get_session_from_url(env))
+    end
+
+    status, headers, body = @app.call(env)
+
+    if is_sync_protocol(env)
+      cookies = headers['Set-Cookie'].to_s
+      #puts "<----- Cookies: #{cookies}"
+      # put cookies to body as JSON on login success
+      if @login_uri_regexp.match(env['PATH_INFO']) && status == 200
+        body = session_json_from(cookies)
+        headers['Content-Length'] = body.length.to_s
+      end
+    end
+
+    # The Body itself should not be an instance of String,as this will break in Ruby 1.9
+    body = ["#{body}"] if body.is_a?(String)
+    [status, headers, body]
+  end
+
+  def session_json_from(cookies)
+    rexp = Regexp.new(@session_cookie +'=[^\s]*')
+    sc = cookies.to_s.slice rexp
+    "{\"" +@session_cookie +"\": \"#{CGI.escape sc.to_s}\"}"
+  end
+
+  def get_session_from_url(env)
+    rexp = Regexp.new(@session_cookie +'=.*\Z')
+    qs = env['QUERY_STRING'].to_s.slice rexp
+    qs = qs.to_s.split(/&/)[0]
+    nv = qs.to_s.split(/=/)
+    return nv[1] if nv.length > 1
+    ''
+  end
+end

data/lib/rhoconnect.rb

@@ -0,0 +1,285 @@
+require 'redis'
+require 'cgi'
+require 'json'
+require 'base64'
+require 'zip/zip'
+require 'yaml'
+require 'rhoconnect/license'
+require 'rhoconnect/version'
+require 'rhoconnect/document'
+require 'rhoconnect/lock_ops'
+require 'rhoconnect/model'
+require 'rhoconnect/source'
+require 'rhoconnect/store'
+require 'rhoconnect/stats/record'
+require 'rhoconnect/stats/middleware'
+require 'rhoconnect/user'
+require 'rhoconnect/api_token'
+require 'rhoconnect/app'
+require 'rhoconnect/client'
+require 'rhoconnect/read_state'
+require 'rhoconnect/client_sync'
+require 'rhoconnect/source_adapter'
+require 'rhoconnect/source_sync'
+require 'rhoconnect/rho_indifferent_access'
+require 'rhoconnect/jobs/source_job'
+require 'rhoconnect/jobs/ping_job'
+require 'rhoconnect/bulk_data'
+require 'rhoconnect/db_adapter'
+require 'rhoconnect/dynamic_adapter'
+
+REDIS_URL = 'REDIS' unless defined? REDIS_URL
+  
+# Various module utilities for the store
+module Rhoconnect
+  APP_NAME = 'application' unless defined? APP_NAME
+  
+  class InvalidArgumentError < RuntimeError; end
+  class RhoconnectServerError < RuntimeError; end
+  
+  # Used by application authenticate to indicate login failure
+  class LoginException < RuntimeError; end
+  
+  extend self
+    
+  class << self
+    attr_accessor :base_directory, :app_directory, :data_directory, 
+      :vendor_directory, :blackberry_bulk_sync, :redis, :environment,
+      :log_disabled, :license, :bulk_sync_poll_interval, :stats, :appserver, :api_token,
+      :raise_on_expired_lock, :lock_duration, :cookie_expire
+  end
+  
+  ### Begin Rhoconnect setup methods  
+  # Server hook to initialize Rhoconnect
+  def bootstrap(basedir)
+    config = get_config(basedir)
+    #Load environment
+    environment = (ENV['RHO_ENV'] || ENV['RACK_ENV'] || :development).to_sym  
+    # Initialize Rhoconnect and Resque
+    Rhoconnect.base_directory = basedir    
+    Rhoconnect.app_directory = get_setting(config,environment,:app_directory)
+    Rhoconnect.data_directory = get_setting(config,environment,:data_directory)
+    Rhoconnect.vendor_directory = get_setting(config,environment,:vendor_directory)
+    Rhoconnect.blackberry_bulk_sync = get_setting(config,environment,:blackberry_bulk_sync,false)
+    Rhoconnect.bulk_sync_poll_interval = get_setting(config,environment,:bulk_sync_poll_interval,3600)
+    Rhoconnect.redis = get_setting(config,environment,:redis,false)
+    Rhoconnect.appserver = get_setting(config,environment,:appserver,false)
+    Rhoconnect.api_token = ENV['API_TOKEN'] || get_setting(config,environment,:api_token,false)
+    Rhoconnect.log_disabled = get_setting(config,environment,:log_disabled,false)
+    Rhoconnect.raise_on_expired_lock = get_setting(config,environment,:raise_on_expired_lock,false)
+    Rhoconnect.lock_duration = get_setting(config,environment,:lock_duration)
+    Rhoconnect.environment = environment
+    Rhoconnect.cookie_expire = get_setting(config,environment,:cookie_expire)  || 31536000
+    yield self if block_given?
+    Store.create(Rhoconnect.redis)
+    Resque.redis = Store.db
+    Rhoconnect.base_directory ||= File.join(File.dirname(__FILE__),'..')
+    Rhoconnect.app_directory ||= Rhoconnect.base_directory
+    Rhoconnect.data_directory ||= File.join(Rhoconnect.base_directory,'data')
+    Rhoconnect.vendor_directory ||= File.join(Rhoconnect.base_directory,'vendor')
+    Rhoconnect.stats ||= false
+    Rhoconnect.license = License.new
+    
+    check_and_add(File.join(Rhoconnect.app_directory,'sources'))
+    start_app(config)
+    create_admin_user
+    check_hsql_lib! if Rhoconnect.blackberry_bulk_sync
+  end
+  
+  def start_app(config)
+    if config and config[Rhoconnect.environment]
+      app = nil
+      app_name = APP_NAME
+      if App.is_exist?(app_name)
+        app = App.load(app_name)
+      else
+        app = App.create(:name => app_name)
+      end
+      sources = config[:sources] || []
+      Source.delete_all
+      app.delete_sources
+      sources.each do |source_name,fields|
+        check_for_schema_field!(fields)
+        fields[:name] = source_name
+        Source.create(fields,{:app_id => app.name})
+        app.sources << source_name
+        # load ruby file for source adapter to re-load class
+        load under_score(source_name+'.rb')
+      end
+      # Create associations for all sources
+      Source.update_associations(app.sources)
+    end
+  end
+  
+  # Generate admin user on first load
+  def create_admin_user
+    unless User.is_exist?('rhoadmin')
+      admin = User.create({:login => 'rhoadmin', :admin => 1})
+      admin.password = ENV['PSWRD'] || ''
+      admin.create_token
+    end
+  end
+
+  # Add path to load_path unless it has been added already
+  def check_and_add(path)
+    $:.unshift path unless $:.include?(path) 
+  end
+
+  def get_config(basedir)
+    # Load settings
+    settings_file = File.join(basedir,'settings','settings.yml') if basedir
+    YAML.load_file(settings_file) if settings_file and File.exist?(settings_file)
+  end
+  
+  def source_config
+    { "sources" => Rhoconnect.get_config(Rhoconnect.base_directory)[:sources] }
+  end
+  ### End Rhoconnect setup methods  
+  
+  
+  def check_default_secret!(secret)
+    if secret == '<changeme>'                        
+      log "*"*60+"\n\n"
+      log "WARNING: Change the session secret in config.ru from <changeme> to something secure."
+      log "  i.e. running `rake secret` in a rails app will generate a secret you could use.\n\n"
+      log "*"*60
+    end
+  end
+  
+  def check_for_schema_field!(fields)
+    if fields['schema']
+      log "ERROR: 'schema' field in settings.yml is not supported anymore, please use source adapter schema method!"
+      exit(1)
+    end
+  end
+
+  # Serializes oav to set element
+  def setelement(obj,attrib,value)
+    #"#{obj}:#{attrib}:#{Base64.encode64(value.to_s)}"
+    "#{obj}:#{attrib}:#{value.to_s}"
+  end
+
+  # De-serializes oav from set element
+  def getelement(element)
+    res = element.split(':',3)
+    #[res[0], res[1], Base64.decode64(res[2].to_s)]
+    [res[0], res[1], res[2]]
+  end
+
+  # Get random UUID string
+  def get_random_uuid
+    UUIDTools::UUID.random_create.to_s.gsub(/\-/,'')
+  end
+
+  # Generates new token (64-bit integer) based on # of 
+  # microseconds since Jan 1 2009
+  def get_token
+    ((Time.now.to_f - Time.mktime(2009,"jan",1,0,0,0,0).to_f) * 10**6).to_i
+  end
+
+  # Computes token for a single client request
+  def compute_token(doc_key)
+    token = get_token
+    Store.put_value(doc_key,token)
+    token.to_s
+  end
+
+  # Returns require-friendly filename for a class
+  def under_score(camel_cased_word)
+    camel_cased_word.to_s.gsub(/::/, '/').
+    gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+    gsub(/([a-z\d])([A-Z])/,'\1_\2').
+    tr("-", "_").
+    downcase
+  end
+
+  # Taken from rails inflector
+  def camelize(lower_case_and_underscored_word, first_letter_in_uppercase = true)
+    if first_letter_in_uppercase
+      lower_case_and_underscored_word.to_s.gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
+    end
+  end
+
+  def check_hsql_lib!
+    unless File.exists?(File.join(Rhoconnect.vendor_directory,'hsqldata.jar'))
+      log "*"*60
+      log ""
+      log "WARNING: Missing vendor/hsqldata.jar, please install it for BlackBerry bulk sync support."
+      log ""
+      log "*"*60
+    end
+  end
+  
+  def expire_bulk_data(username, partition = :user)
+    name = BulkData.get_name(partition,username)
+    data = BulkData.load(name)
+    data.refresh_time = Time.now.to_i if data
+  end
+
+  def unzip_file(file_dir,params)
+    uploaded_file = File.join(file_dir, params[:filename])
+    begin
+      File.open(uploaded_file, 'wb') do |file|
+        file.write(params[:tempfile].read)
+      end
+      Zip::ZipFile.open(uploaded_file) do |zip_file|
+        zip_file.each do |f|
+          f_path = File.join(file_dir,f.name)
+          FileUtils.mkdir_p(File.dirname(f_path))
+          zip_file.extract(f, f_path) { true }
+        end
+      end
+    rescue Exception => e
+      log "Failed to unzip `#{uploaded_file}`"
+      raise e
+    ensure
+      FileUtils.rm_f(uploaded_file)
+    end
+  end
+
+  def lap_timer(msg,start)
+    duration = timenow - start
+    log "#{msg}: #{duration}"
+    timenow
+  end
+
+  def start_timer(msg='starting')
+    log "#{msg}"
+    timenow
+  end
+
+  def timenow
+    (Time.now.to_f * 1000)
+  end
+  
+  def log(*args)
+    now = Time.now.strftime('%I:%M:%S %p %Y-%m-%d')
+    puts "[#{now}] #{args.join}" unless Rhoconnect.log_disabled
+  end
+  
+  # Base rhoconnect application class
+  class Base    
+    # Add everything in vendor to load path
+    # TODO: Integrate with 3rd party dependency management
+    def self.initializer(path=nil)
+      Dir["vendor/*"].each do |dir|
+        $:.unshift File.join(dir,'lib')
+      end
+      require 'rhoconnect'
+      require 'rhoconnect/server'
+      # Bootstrap Rhoconnect system
+      Rhoconnect.bootstrap(path || ENV['PWD'])
+    end
+    
+    def self.store_blob(obj,field_name,blob)
+      blob[:tempfile].path if blob[:tempfile]
+    end
+  end
+  
+  protected
+  def get_setting(config,environment,setting,default=nil)
+    res = nil
+    res = config[environment][setting] if config and environment 
+    res || default
+  end
+end

data/rhoconnect.gemspec

@@ -0,0 +1,67 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "rhoconnect/version"
+
+Gem::Specification.new do |s|
+  s.name        = "rhoconnect"
+  s.version     = Rhoconnect::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Rhomobile"]
+  s.date        = Time.now.strftime('%Y-%m-%d')
+  s.email       = %q{dev@rhomobile.com}
+  s.homepage    = %q{http://rhomobile.com/products/rhoconnect}
+  s.summary     = %q{RhoConnect Server Framework}
+  s.description = %q{RhoConnect Server Framework and related command-line utilities}
+
+  s.rubyforge_project = nil
+
+  # s.files         = `git ls-files`.split("\n")
+  # s.test_files    = `git ls-files -- {examples,spec,features}/*`.split("\n")
+  # s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.files        = %w( 
+    CHANGELOG CREDITS Gemfile Gemfile.lock install.sh README.md Rakefile LICENSE Rakefile rhoconnect.gemspec 
+  )
+  s.files       += Dir.glob("bench/**/*")
+  s.files       += Dir.glob("doc/**/*")
+  s.files       += Dir.glob("examples/**/*")
+  s.files       += Dir.glob("generators/**/*")
+  s.files       += Dir.glob("installer/**/*")
+  s.files       += Dir.glob("lib/**/*")
+  s.files       += Dir.glob("tasks/**/*")
+  s.test_files   = Dir.glob("spec/**/*")
+  s.executables  = Dir.glob("bin/*").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.rubygems_version = %q{1.5.0}
+  s.extra_rdoc_files = [
+    "LICENSE",
+    "README.md"
+  ]
+
+  s.add_dependency('bundler', '~> 1.0')  
+  s.add_dependency("sinatra", '~> 1.2')
+  s.add_dependency('rake', '0.9.2')
+  s.add_dependency('json', '~> 1.5.0')
+  s.add_dependency('rubyzip', '~> 0.9.4')
+  s.add_dependency('uuidtools', '>= 2.1.1')
+  s.add_dependency('redis', '>= 2.2.0')
+  s.add_dependency('resque', '~> 1.17.0')
+  s.add_dependency('rest-client', '~> 1.6.1')
+  s.add_dependency('templater', '~> 1.0.0')
+
+  # Platform specific gems
+  if defined?(JRUBY_VERSION)
+    s.add_dependency('jdbc-sqlite3', ">= 3.7.2")
+    s.add_dependency('dbi', ">= 0.4.5")
+    s.add_dependency('dbd-jdbc', ">= 0.1.4")
+    s.add_dependency('jruby-openssl', ">= 0.7.4")
+  else
+    s.add_dependency('sqlite3', ">= 1.3.3")
+    # Helps with some of the limitations of green threads, not needed in ruby 1.9.x
+    if RUBY_VERSION =~ /1.8/
+      s.add_dependency('SystemTimer', '~> 1.2.3')
+    end
+  end
+  
+end

data/spec/api/admin/api_token_spec.rb

@@ -0,0 +1,14 @@
+require File.join(File.dirname(__FILE__),'..','..','spec_helper')
+require File.join(File.dirname(__FILE__), '..','..','support', 'shared_examples')
+
+describe "ApiToken" do
+  it_behaves_like "SharedRhoconnectHelper", :rhoconnect_data => true do
+    it "should generate api token with user" do
+      token = ApiToken.create(:user_id => @u.id)
+      token.value.length.should == 32
+      token.user_id.should == @u.id
+      token.user.login.should == @u.login
+      token.delete
+    end
+  end
+end

data/spec/api/admin/get_api_token_spec.rb

@@ -0,0 +1,36 @@
+require File.join(File.dirname(__FILE__),'..','api_helper')
+
+describe "RhoconnectApiGetApiToken" do
+  it_should_behave_like "ApiHelper" do
+    it "should login and receive the token string" do
+      post "/api/admin/login", :login => 'rhoadmin',:password => ''
+      last_response.body.should == @api_token
+    end
+    
+    it "should login using the old route and show deprecation warning" do
+      post "/login", :login => 'rhoadmin',:password => ''
+      last_response.body.should == @api_token
+      last_response.headers["Warning"].index('deprecated').should_not == nil
+    end
+    
+    it "should get deprecation warning for get_api_token method" do
+      post "/api/admin/login", :login => 'rhoadmin',:password => ''
+      post "/api/admin/get_api_token"
+      last_response.body.should == @api_token
+      last_response.headers['Warning'].index('deprecated').should_not == nil
+    end
+
+    it "should fail to login and get token if user is not rhoadmin" do
+      Rhoconnect.appserver = nil
+      post "/api/admin/login", :login => @u_fields[:login],:password => 'testpass'
+      last_response.status.should == 422    
+      last_response.body.should == 'Invalid/missing API user'
+    end  
+
+    it "should return 422 if no token provided" do
+      params = {:attributes => {:login => 'testuser1', :password => 'testpass1'}}
+      post "/api/user/create_user", params
+      last_response.status.should == 422
+    end
+  end  
+end

data/spec/api/admin/get_license_info_spec.rb

@@ -0,0 +1,38 @@
+require File.join(File.dirname(__FILE__),'..','api_helper')
+
+describe "RhoconnectApiGetLicenseInfo" do
+  it_should_behave_like "ApiHelper" do
+    it "should get license info" do
+      true.should == true
+      post "/api/admin/get_license_info", {:api_token => @api_token}
+      JSON.parse(last_response.body).should == {
+        "available" => 9, 
+        "issued" => "Fri Apr 23 17:20:13 -0700 2010", 
+        "seats" => 10, 
+        "rhoconnect_version" => "Version 1",
+        "licensee" => "Rhomobile" }
+    end
+    
+    it "should get custom_license info with deprecation warning" do
+      true.should == true
+      
+      # this one for test purposes to make sure
+      # that an old way custom REST API still works
+      Rhoconnect::Server.api :custom_license_info do |params,user|
+        {:rhoconnect_version => Rhoconnect.license.rhoconnect_version, 
+         :licensee => Rhoconnect.license.licensee, 
+         :seats => Rhoconnect.license.seats, 
+         :issued => Rhoconnect.license.issued,
+         :available => Rhoconnect.license.available }.to_json
+      end
+      
+      post "/api/custom_license_info", {:api_token => @api_token}
+      JSON.parse(last_response.body).should == {
+        "available" => 9, 
+        "issued" => "Fri Apr 23 17:20:13 -0700 2010", 
+        "seats" => 10, 
+        "rhoconnect_version" => "Version 1",
+        "licensee" => "Rhomobile" }
+    end
+  end  
+end

data/spec/api/admin/reset_spec.rb

@@ -0,0 +1,22 @@
+require File.join(File.dirname(__FILE__),'..','api_helper')
+
+describe "RhoconnectApiReset" do
+  it_should_behave_like "ApiHelper" do
+    it "should reset and re-create rhoadmin user with bootstrap" do
+      Store.put_data('somedoc',{ '1' => {'foo'=>'bar'}})
+      post "/api/admin/reset", :api_token => @api_token
+      App.is_exist?(test_app_name).should == true
+      Store.get_data('somedoc').should == {}
+      User.authenticate('rhoadmin','').should_not be_nil
+    end
+
+    it "should reset and re-create rhoadmin user with initializer" do
+      Store.put_data('somedoc',{ '1' => {'foo'=>'bar'}})
+      post "/api/admin/reset", :api_token => @api_token
+      App.is_exist?(test_app_name).should == true
+      Store.get_data('somedoc').should == {}
+      User.authenticate('rhoadmin','').should_not be_nil
+      load File.join(Rhoconnect.base_directory,test_app_name+'.rb')
+    end
+  end
+end

data/spec/api/admin/stats_spec.rb

@@ -0,0 +1,66 @@
+require File.join(File.dirname(__FILE__),'..','api_helper')
+
+describe "RhoconnectApiStats" do
+  it_should_behave_like "ApiHelper" do
+    before(:each) do
+      Rhoconnect.stats = true
+    end
+
+    after(:each) do
+      Rhoconnect.stats = false
+    end
+
+    it "should retrieve metric names" do
+      Store.set_value('stat:foo', '1')
+      Store.set_value('stat:bar', '2')
+      post "/api/admin/stats", {
+        :api_token => @api_token, 
+        :names => '*'
+      }
+      last_response.should be_ok
+      JSON.parse(last_response.body).sort.should == ['bar', 'foo']
+    end
+
+    it "should retrieve range metric" do
+      Store.db.zadd('stat:foo', 2, "1:2")
+      Store.db.zadd('stat:foo', 3, "1:3")
+      post "/api/admin/stats", {
+        :api_token => @api_token, 
+        :metric => 'foo', 
+        :start => 0,
+        :finish => -1
+      }
+      last_response.should be_ok
+      JSON.parse(last_response.body).should == ["1:2", "1:3"]
+    end
+
+    it "should retrieve string metric" do
+      Store.db.set('stat:foo', 'bar')
+      post "/api/admin/stats", {
+        :api_token => @api_token, 
+        :metric => 'foo'
+      }
+      last_response.should be_ok
+      last_response.body.should == 'bar'
+    end
+
+    it "should raise error on unknown metric" do
+      post "/api/admin/stats", {
+        :api_token => @api_token, 
+        :metric => 'foo'
+      }
+      last_response.status.should == 404    
+      last_response.body.should == 'Unknown metric'
+    end
+
+    it "should raise error if stats not enabled" do
+      Rhoconnect.stats = false
+      post "/api/admin/stats", {
+        :api_token => @api_token, 
+        :metric => 'foo'
+      }
+      last_response.status.should == 500    
+      last_response.body.should == 'Stats not enabled'
+    end
+  end  
+end

data/spec/api/api_helper.rb

@@ -0,0 +1,21 @@
+require 'rack/test'
+require 'rspec'
+
+require File.join(File.dirname(__FILE__),'..','..','lib','rhoconnect','server.rb')
+require File.join(File.dirname(__FILE__),'..','spec_helper')
+require File.join(File.dirname(__FILE__), '..', 'support', 'shared_examples')
+
+def app
+  @app ||= Rhoconnect::Server.new
+end
+
+def compress(path)
+  path.sub!(%r[/$],'')
+  archive = File.join(path,File.basename(path))+'.zip'
+  FileUtils.rm archive, :force=>true
+  Zip::ZipFile.open(archive, 'w') do |zipfile|
+    Dir["#{path}/**/**"].reject{|f|f==archive}.each do |file|
+      zipfile.add(file.sub(path+'/',''),file)
+    end
+  end
+end