rhoconnect 3.0.0.beta1

data/lib/rhoconnect/console/app/views/user.erb

@@ -0,0 +1,29 @@
+<h1>User: <%=params[:user_id]%></h1>
+<%=show_errors%>
+<div class="panel">
+	<a href='<%=url_path("user/delete?user_id=#{CGI.escape(params[:user_id])}")%>' class='nav_button'>Delete user</a>
+</div>
+<div class="panel">	
+	<a href='<%=url_path("user/ping?user_id=#{CGI.escape(params[:user_id])}")%>' class='nav_button'>Ping User</a>
+</div>
+<h2>User partition sources</h2>	
+
+[
+<%@sources.each_index do |i|%>
+	<a href='javascript:void(0);' onclick="loadXMLDoc('<%=url_path("docs?source_id=#{@sources[i]}&user_id=#{CGI.escape(params[:user_id])}")%>','main_box');"><%=i==0?'':','%>"<%=@sources[i]%>"</a>
+<%end%>
+]
+
+<h2>Registered Devices</h2>
+
+<a href="javascript:void(0);" onclick="loadXMLDoc('<%=url_path("device/create?user_id=#{CGI.escape(params[:user_id])}")%>','');loadXMLDoc('<%=url_path("user?user_id=#{CGI.escape(params[:user_id])}")%>','main_box');" class='nav_button'>Create Device</a>
+
+<div class="panel">
+[ 	
+<%@devices.each_index do |i|%>
+	<a href="javascript:void(0);" onclick="loadXMLDoc('<%=url_path("device?user_id=#{CGI.escape(params[:user_id])}&device_id=#{CGI.escape(@devices[i])}")%>','main_box');">
+		<%=i==0?'':','%>"<%=@devices[i]%>"
+	</a>
+<%end%>
+]
+</div>

data/lib/rhoconnect/console/app/views/users.erb

@@ -0,0 +1,12 @@
+<a href="javascript:void(0);" onclick="loadXMLDoc('<%=url_path('user/new')%>','main_box');" class='nav_button'>Create User</a>
+
+<h2>Registered users</h2>
+<%if is_errors?%>
+	<%= show_errors%>
+<%else%>
+	[ 	
+	<%@users.each_index do |i|%>
+		<a href="javascript:void(0);" onclick="loadXMLDoc('<%=url_path("user?user_id=#{CGI.escape(@users[i])}")%>','main_box');"><%=i==0?'':','%>"<%=@users[i]%>"</a>
+	<%end%>
+	]
+<%end%>

data/lib/rhoconnect/console/rhoconnect_api.rb

@@ -0,0 +1,245 @@
+require 'rest_client'
+path = File.join(File.dirname(__FILE__),'..','..')
+$:.unshift path
+require 'rhoconnect'
+include Rhoconnect
+
+module RhoconnectApi
+  class << self
+
+    def get_token(server,login,password)
+      if directcall?(server)
+        Server.get_api_token(nil,User.authenticate(login,password))
+      else  
+        do_login(server,login,password)
+      end
+    end
+    
+    def list_users(server,token)
+      if directcall?(server) and verify_token(token)
+        JSON.parse(Server.list_users(nil,api_user(token)))
+      else  
+        JSON.parse(RestClient.post("#{server}/api/user/list_users",
+            {:api_token => token}.to_json, :content_type => :json).body)
+      end
+    end
+    
+    def save_adapter(server,token,adapter_url)
+      if directcall?(server) and verify_token(token)
+        Server.save_adapter({:attributes => {'adapter_url' => adapter_url}},nil)
+      else  
+        RestClient.post("#{server}/api/source/save_adapter",
+          {:api_token => token,:attributes => {:adapter_url => adapter_url}}.to_json, 
+            :content_type => :json)
+      end
+    end
+    
+    def create_user(server,token,login,password)
+      if directcall?(server) and verify_token(token)
+        Server.create_user({:attributes => {'login' => login, 'password' => password}},nil)
+      else  
+        RestClient.post("#{server}/api/user/create_user",
+          {:api_token => token,:attributes => {:login => login, :password => password}}.to_json, 
+            :content_type => :json)
+      end  
+    end  
+
+    def update_user(server,token,attributes)
+      if directcall?(server) and verify_token(token)
+        Server.update_user({:attributes => attributes},api_user(token))
+      else  
+        RestClient.post("#{server}/api/user/update_user",
+          {:api_token => token,:attributes => attributes}.to_json, 
+            :content_type => :json)
+      end  
+    end
+    
+    def delete_user(server,token,user_id)
+      if directcall?(server) and verify_token(token)
+        Server.delete_user({:user_id => user_id},nil)
+      else
+        RestClient.post("#{server}/api/user/delete_user",
+          {:api_token => token, :user_id => user_id}.to_json, 
+           :content_type => :json)
+      end    
+    end
+  
+    def list_clients(server,token,user_id)
+      if directcall?(server) and verify_token(token)
+        JSON.parse(Server.list_clients({:user_id => user_id},nil))
+      else
+        JSON.parse(RestClient.post("#{server}/api/client/list_clients", 
+          {:api_token => token, :user_id => user_id}.to_json, :content_type => :json).body)
+      end
+    end
+    
+    def create_client(server,token,user_id)
+      if directcall?(server) and verify_token(token)
+        Server.create_client({:user_id => user_id},nil)
+      else  
+        RestClient.post("#{server}/api/client/create_client",
+          {:api_token => token, :user_id => user_id}.to_json, 
+           :content_type => :json).body
+      end
+    end  
+    
+    def delete_client(server,token,user_id,client_id)
+      if directcall?(server) and verify_token(token)
+        Server.delete_client({:user_id => user_id,:client_id => client_id},nil)
+      else
+        RestClient.post("#{server}/api/client/delete_client",
+          {:api_token => token, :user_id => user_id, 
+           :client_id => client_id}.to_json, :content_type => :json)    
+      end     
+    end
+
+    def get_client_params(server,token,client_id)
+      if directcall?(server) and verify_token(token)
+        JSON.parse(Server.get_client_params({:client_id => client_id},nil))
+      else
+        JSON.parse(RestClient.post("#{server}/api/client/get_client_params", 
+          {:api_token => token, :client_id => client_id}.to_json, :content_type => :json).body)
+      end
+    end
+    
+    def get_adapter(server,token)
+      if directcall?(server) and verify_token(token)
+        JSON.parse(Server.get_adapter({},nil))
+      else
+        JSON.parse(RestClient.post("#{server}/api/source/get_adapter", 
+          {:api_token => token}.to_json, :content_type => :json).body)
+      end
+    end
+    
+    def list_sources(server,token,partition='all')
+      if directcall?(server) and verify_token(token)
+        JSON.parse(Server.list_sources({:partition_type => partition.to_s},nil))
+      else
+        JSON.parse(RestClient.post("#{server}/api/source/list_sources", 
+          {:api_token => token, :partition_type => partition}.to_json, :content_type => :json).body)
+      end
+    end
+
+    def get_source_params(server,token,source_id)
+      if directcall?(server) and verify_token(token)
+        JSON.parse(Server.get_source_params({:source_id => source_id},nil))
+      else  
+        JSON.parse(RestClient.post("#{server}/api/source/get_source_params", 
+          {:api_token => token, :source_id => source_id}.to_json, :content_type => :json).body)
+      end
+    end
+    
+    def list_source_docs(server,token,source_id,user_id='*')
+      if directcall?(server) and verify_token(token)
+        JSON.parse(Server.list_source_docs({:source_id => source_id, :user_id => user_id},nil))
+      else  
+        JSON.parse(RestClient.post("#{server}/api/source/list_source_docs", 
+          {:api_token => token, :source_id => source_id, :user_id => user_id}.to_json, :content_type => :json).body)
+      end
+    end  
+      
+    def list_client_docs(server,token,source_id,client_id)
+      if directcall?(server) and verify_token(token)
+        JSON.parse(Server.list_client_docs({:source_id => source_id, :client_id => client_id},nil))
+      else  
+        JSON.parse(RestClient.post("#{server}/api/client/list_client_docs", 
+          {:api_token => token, :source_id => source_id, :client_id => client_id}.to_json, :content_type => :json).body)
+      end    
+    end  
+    
+    #TODO: figure out data_type programmatically     
+    def get_db_doc(server,token,doc,data_type='')
+      res = ""
+      if directcall?(server) and verify_token(token)
+        res = Server.get_db_doc({:doc => doc, :data_type => data_type},nil)
+      else
+        res = RestClient.post("#{server}/api/source/get_db_doc", 
+          {:api_token => token, :doc => doc, :data_type => data_type}.to_json, :content_type => :json).body
+      end 
+      data_type=='' ? JSON.parse(res) : res
+    end
+
+    #TODO: figure out data_type programmatically     
+    def set_db_doc(server,token,doc,data={},data_type='')
+      if directcall?(server) and verify_token(token)
+        Server.set_db_doc({:doc => doc, :data => data, :data_type => data_type},nil)
+      else  
+        RestClient.post("#{server}/api/source/set_db_doc", 
+         {:api_token => token, :doc => doc, :data => data, :data_type => data_type}.to_json, :content_type => :json)
+      end   
+    end
+          
+    def reset(server,token)
+      if directcall?(server) and verify_token(token)
+        Server.reset({:api_token => token},api_user(token))
+      else  
+        RestClient.post("#{server}/api/admin/reset",
+          {:api_token => token}.to_json, :content_type => :json)
+      end
+    end
+    
+    def ping(server,token,user_id,params)
+      ping_params = {'api_token' => token, 'user_id' => user_id}
+      [:message,:badge,:sound,:vibrate,:sources,:async].each do |part|
+        part = part.to_s
+        ping_params.merge!(part => params[part]) if params[part]
+      end
+      if directcall?(server) and verify_token(token)
+        Server.ping(ping_params,nil)
+      else  
+        RestClient.post("#{server}/api/client/ping",ping_params.to_json, :content_type => :json)
+      end  
+    end
+
+    def get_license_info(server,token)
+      if directcall?(server) and verify_token(token)
+        JSON.parse(Server.get_license_info(nil,nil))
+      else  
+        JSON.parse(RestClient.post("#{server}/api/admin/get_license_info",
+          {:api_token => token}.to_json, :content_type => :json).body)
+      end
+    end
+    
+    def stats(server,token,params)
+      if directcall?(server) and verify_token(token)
+        Server.stats(params,api_user(token))
+      else  
+        RestClient.post("#{server}/api/admin/stats",
+          {:api_token => token}.merge!(params).to_json, :content_type => :json).body
+      end
+    end
+    
+    private
+    
+    def do_login(server,login,password)
+      RestClient.post("#{server}/api/admin/admin",
+        {:login => login, :password => password}.to_json,
+         :content_type => :json).body
+    end
+    
+    def directcall?(server)
+      server.nil? or server.length == 0
+    end
+    
+    def api_user(token)
+      ApiToken.load(token).user
+    end
+    
+    def verify_token(token)
+      raise ApiException.new(422, "Invalid/missing API user") unless api_user(token); true
+    end
+  end
+  
+  class Server
+    def self.api(method_name,namespace = nil, verb = :post, &block)
+      self.class.send(:define_method, method_name, &block) unless namespace == :application
+    end  
+    
+    def self.app_api(method_name, namespace = nil, verb = :post, &block)
+      # this is not used in RhoconnectAPI::Server
+    end
+  end
+end
+
+include RhoconnectApi
+Dir[File.join(File.dirname(__FILE__),'..','api','**','*.rb')].each { |api| load api }

data/lib/rhoconnect/console/server.rb

@@ -0,0 +1,32 @@
+$:.unshift File.dirname(__FILE__)
+require 'rubygems'
+require 'sinatra/base'
+require 'erb'
+require 'json'
+require 'rhoconnect_api'
+
+module RhoconnectConsole  
+  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,  RhoconnectConsole::root_path("app","views")
+    set :public, RhoconnectConsole::root_path("app","public")
+    set :static, true    
+    use Rack::Session::Cookie
+    HEROKU_NAV = ENV['INSTANCE_ID'] ? RestClient.get('http://nav.heroku.com/v1/providers/header') : nil
+    before do
+      headers['Expires'] = 'Sun, 19 Nov 1978 05:00:00 GMT'
+      headers['Cache-Control'] = 'no-store, no-cache, must-revalidate'  
+      headers['Pragma'] = 'no-cache'
+    end
+  end
+end
+
+Dir[File.join(File.dirname(__FILE__),"app/**/*.rb")].each do |file|
+  require file
+end

data/lib/rhoconnect/console.rb

@@ -0,0 +1,3 @@
+path = File.join(File.dirname(__FILE__),'..','..','lib')
+$:.unshift path
+ROOT_PATH = File.expand_path(File.dirname(__FILE__))

data/lib/rhoconnect/cors.rb

@@ -0,0 +1,229 @@
+require 'logger'
+
+module Rack
+  class Cors
+    def initialize(app, opts={})
+      @app = app
+      @logger = opts[:logger]
+      yield self if block_given?
+    end
+
+    def allow
+      all_resources << (resources = Resources.new)
+      yield resources
+    end
+
+    def call(env)
+      if env['HTTP_ORIGIN'] == 'null'
+        env['HTTP_ORIGIN'] = 'file://'
+      end
+      if env['HTTP_X_ORIGIN'] and not env['HTTP_ORIGIN']
+        puts 'ORIGIN header is empty, X-ORIGIN workaround header applied.'
+        env['HTTP_ORIGIN'] = env['HTTP_X_ORIGIN']
+      end
+      cors_headers = nil
+      if env['HTTP_ORIGIN']
+        debug(env) do
+          [ 'Incoming Headers:',
+            "  Origin: #{env['HTTP_ORIGIN']}",
+            "  Access-Control-Request-Method: #{env['HTTP_ACCESS_CONTROL_REQUEST_METHOD']}",
+            "  Access-Control-Request-Headers: #{env['HTTP_ACCESS_CONTROL_REQUEST_HEADERS']}"
+            ].join("\n")
+        end
+        if env['REQUEST_METHOD'] == 'OPTIONS'
+          if headers = process_preflight(env)
+            debug(env) do
+              "Preflight Headers:\n" +
+                  headers.collect{|kv| "  #{kv.join(': ')}"}.join("\n")
+            end
+            return [200, headers, ['']]
+          end
+        else
+          cors_headers = process_cors(env)
+        end
+      end
+      status, headers, body = @app.call env
+      headers = headers.merge(cors_headers) if cors_headers
+      [status, headers, body]
+    end
+
+    protected
+      def debug(env, message = nil, &block)
+        logger = @logger || env['rack.logger'] || begin
+          @logger = ::Logger.new(STDOUT).tap {|logger| logger.level = ::Logger::Severity::INFO}
+        end
+        logger.debug(message, &block)
+        #TODO: remove debug output from code!
+        message = yield
+        puts message
+      end
+
+      def all_resources
+        @all_resources ||= []
+      end
+
+      def process_preflight(env)
+        resource = find_resource(env['HTTP_ORIGIN'], env['PATH_INFO'])
+        resource && resource.process_preflight(env)
+      end
+
+      def process_cors(env)
+        resource = find_resource(env['HTTP_ORIGIN'], env['PATH_INFO'])
+        resource.to_headers(env) if resource
+      end
+
+      def find_resource(origin, path)
+        allowed = all_resources.detect {|r| r.allow_origin?(origin)}
+        allowed ? allowed.find_resource(path) : nil
+      end
+
+      class Resources
+
+        def initialize
+          @origins = []
+          @resources = []
+          @public_resources = false
+        end
+
+        def origins(*args)
+          @origins = args.flatten.collect do |n|
+            if n.class == Regexp
+              n
+            else
+              case n
+              when /^[a-z]+:\/\// then n
+              when '*'
+                @public_resources = true
+                n
+              else
+                "http://#{n}"
+              end
+            end
+          end
+        end
+
+        def resource(path, opts={})
+          @resources << Resource.new(public_resources?, path, opts)
+        end
+
+        def public_resources?
+          @public_resources
+        end
+
+        def allow_origin?(source)
+          result = public_resources? || @origins.include?(source) ||
+              (not (@origins.select {|n| n.class == Regexp && n.match(source)}).empty?)
+          #TODO: to fix  "n.match(source)". Unsure, but it may lead to security risks.
+          result
+        end
+
+        def find_resource(path)
+          @resources.detect{|r| r.match?(path)}
+        end
+      end
+
+      class Resource
+        attr_accessor :path, :methods, :headers, :expose, :max_age, :credentials, :pattern
+
+        def initialize(public_resource, path, opts={})
+          self.path        = path
+          self.methods     = ensure_enum(opts[:methods]) || [:get]
+          self.credentials = opts[:credentials] || true
+          self.max_age     = opts[:max_age] || 1728000
+          self.pattern     = compile(path)
+          @public_resource = public_resource
+
+          self.headers = case opts[:headers]
+          when :any then :any
+          when nil then nil
+          else
+            [opts[:headers]].flatten.collect{|h| h.downcase}
+          end
+
+          self.expose = case opts[:expose]
+          when nil then nil
+          else
+            [opts[:expose]].flatten
+          end
+        end
+
+        def match?(path)
+          pattern =~ path
+        end
+
+        def process_preflight(env)
+          return nil if invalid_method_request?(env) || invalid_headers_request?(env)
+          {'Content-Type' => 'text/plain'}.merge(to_preflight_headers(env))
+        end
+
+        def to_headers(env)
+          x_origin = env['HTTP_ACCESS_CONTROL_REQUEST_HEADERS']
+          h = { 'Access-Control-Allow-Origin' => public_resource? ? '*' : env['HTTP_ORIGIN'],
+            'Access-Control-Allow-Methods'    => methods.collect{|m| m.to_s.upcase}.join(', '),
+            'Access-Control-Expose-Headers'    => expose.nil? ? '' : expose.join(', '),
+            'Access-Control-Max-Age'          => max_age.to_s }
+          h['Access-Control-Allow-Credentials'] = 'true' if credentials
+          h
+        end
+
+        protected
+          def public_resource?
+            @public_resource
+          end
+
+          def to_preflight_headers(env)
+            h = to_headers(env)
+            if env['HTTP_ACCESS_CONTROL_REQUEST_HEADERS']
+              h.merge!('Access-Control-Allow-Headers' => env['HTTP_ACCESS_CONTROL_REQUEST_HEADERS'])
+            end
+            h
+          end
+
+          def invalid_method_request?(env)
+            request_method = env['HTTP_ACCESS_CONTROL_REQUEST_METHOD']
+            request_method.nil? || !methods.include?(request_method.downcase.to_sym)
+          end
+
+          def invalid_headers_request?(env)
+            request_headers = env['HTTP_ACCESS_CONTROL_REQUEST_HEADERS']
+            request_headers && !allow_headers?(request_headers)
+          end
+
+          def allow_headers?(request_headers)
+            return false if headers.nil?
+            headers == :any || begin
+              request_headers = request_headers.split(/,\s*/) if request_headers.kind_of?(String)
+              request_headers.all?{|h| headers.include?(h.downcase)}
+            end
+          end
+
+          def ensure_enum(v)
+            return nil if v.nil?
+            [v].flatten
+          end
+
+          def compile(path)
+            if path.respond_to? :to_str
+              special_chars = %w{. + ( )}
+              pattern =
+                path.to_str.gsub(/((:\w+)|[\*#{special_chars.join}])/) do |match|
+                  case match
+                  when "*"
+                    "(.*?)"
+                  when *special_chars
+                    Regexp.escape(match)
+                  else
+                    "([^/?&#]+)"
+                  end
+                end
+              /^#{pattern}$/
+            elsif path.respond_to? :match
+              path
+            else
+              raise TypeError, path
+            end
+          end
+      end
+
+  end
+end

data/lib/rhoconnect/credential.rb

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

@@ -0,0 +1,46 @@
+unless defined?(JRUBY_VERSION)
+  require 'sqlite3'
+else
+  require 'dbi'
+  require 'dbd/Jdbc'
+  require 'jdbc/sqlite3'
+end
+require 'singleton'
+
+class DBAdapter 
+  include Singleton
+
+  # Return the database connection...
+  # For JRuby platform returned connection has extra missing singleton methods ('execute_batch' and 'close'), 
+  # and redefined 'transaction' method (to manage DBI auto-commit behavior)  
+  def get_connection(dbfile)
+    if defined?(JRUBY_VERSION) # JRuby
+      db = DBI.connect("DBI:Jdbc:SQLite:#{dbfile}", nil, nil, 'driver' => 'org.sqlite.JDBC')
+      class << db
+        # jdbc/sqlite3 has no Database#execute_batch method
+        def execute_batch(batch)
+          batch.strip.split(';').each do |sth|
+            self.do(sth.strip)
+          end
+        end
+        
+        # jdbc/sqlite3 instead of 'close' uses 'disconnect' method
+        def close
+          self.disconnect
+        end
+
+        alias_method :do_transaction, :transaction
+        # Disable auto-commit, perform transaction and restore default DBI auto-commit behavior 
+        def transaction &block
+          self['AutoCommit'] = false
+          self.do_transaction &block
+          self['AutoCommit'] = true        
+        end          
+      end        
+    else # Ruby 1.8/1.9
+      db = SQLite3::Database.new(dbfile)
+    end
+
+    db 
+  end   
+end

data/lib/rhoconnect/document.rb

@@ -0,0 +1,49 @@
+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 flash_source_data(doctype, from_source)
+    self.source_name=from_source
+    docnamestr = docname('') + doctype
+    Store.flash_data(docnamestr)
+  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