rhoconnect 4.0.0.beta.12 → 4.0.0.beta.24

data/generators/templates/application/rcgemfile

@@ -5,15 +5,12 @@
 gem 'win32-process', '= 0.6.6', :platforms => [:mswin, :mingw]
 
 # use thin and eventmachine everywhere except JRuby
-platforms :ruby, :ruby_19, :mingw, :mingw_19 do
+platforms :ruby, :mingw do
   gem "eventmachine", "~> 1.0.0"
   # using thin by default
   gem 'thin'
-end
-
 # for async framework
 # for Async, Eventful execution
-platforms :ruby_19, :mingw_19 do
   gem 'rack-fiber_pool'
   gem 'async-rack'
 end
@@ -37,5 +34,4 @@ group :test do
   gem 'rspec', '~> 2.10.0'
   gem 'rack-test', '>= 0.5.3', :require => "rack/test"
   gem 'rhomobile-debug', ">= 1.0.2"
-	gem 'capybara'
 end

data/generators/templates/application/spec/spec_helper.rb

@@ -17,15 +17,6 @@ include Rhoconnect
 require 'rhoconnect/application/init'
 require 'rhoconnect/test_methods'
 
-require 'capybara'
-require 'capybara/dsl'
-
-Capybara.app = Sinatra::Application
-
-RSpec.configure do |config|
-  config.include Capybara
-end
-
 shared_examples_for "SpecHelper" do
   include Rhoconnect::TestMethods
 

data/generators/templates/source/models/js/model.js

@@ -43,6 +43,14 @@ var <%=class_name%> = function(){
     // TODO: Logout from the data source if necessary.
     resp.send(true);
   };
+
+  this.storeBlob = function(resp){
+    // TODO: Handle post requests for blobs here.
+    // Reference the blob object's path with resp.params.path.
+    new rc.Exception(
+      resp, "Please provide some code to handle blobs if you are using them."
+    );
+  };
 };
 
 module.exports = new <%=class_name%>();

data/generators/templates/source/models/ruby/model.rb

@@ -38,15 +38,9 @@ class <%=class_name%> < Rhoconnect::Model::Base
     # TODO: Logout from the data source if necessary
   end
 
-  # Calling super here returns rack tempfile path:
-  # i.e. /var/folders/J4/J4wGJ-r6H7S313GEZ-Xx5E+++TI
-  # Note: This tempfile is removed when server stops or crashes...
-  # See http://rack.rubyforge.org/doc/Multipart.html for more info
-  #
-  # Uncomment this code and override it by creating a copy of the file somewhere
-  # and returning the path to that file (then don't call super!):
-  # i.e. /mnt/myimages/soccer.png
-  #def store_blob(object,field_name,blob)
-  #  super #=> returns blob[:tempfile]
-  #end
+  def store_blob(object,field_name,blob)
+    # TODO: Handle post requests for blobs here.
+    # make sure you store the blob object somewhere permanently
+    raise "Please provide some code to handle blobs if you are using them."
+  end
 end

data/install.sh

@@ -258,10 +258,10 @@ rubyVersion=""
 rubyBinDir=""
 
 # Define ruby and nodejs versions to be installed ...
-RUBY_PATCH="p392"
+RUBY_PATCH="p429"
 RUBY_VERSION="ruby-1.9.3-${RUBY_PATCH}"
 
-NODE_VERSION=v0.10.4
+NODE_VERSION=v0.10.5
 NODE_URL=http://nodejs.org/dist/${NODE_VERSION}/node-${NODE_VERSION}.tar.gz
 ARCH=$([[ `uname -m` == x86_64 ]] && echo "x64" || echo "x86")
 NODE_BIN_URL=http://nodejs.org/dist/${NODE_VERSION}/node-${NODE_VERSION}-linux-${ARCH}.tar.gz

data/installer/unix-like/rho_connect_install_constants.rb

@@ -8,10 +8,10 @@ module Constants
                            "libaprutil1-dev",
                            "dtach"]
 
-  RUBY                    = "ruby-1.9.3-p392"
-  REDIS                   = "redis-2.6.10"
+  RUBY                    = "ruby-1.9.3-p429"
+  REDIS                   = "redis-2.6.13"
   SQLITE3                 = "sqlite-autoconf-3071502"
-  NGINX                   = "nginx-1.3.13"
+  NGINX                   = "nginx-1.4.1"
   PASSENGER_ROOT          = "/opt/rhoconnect/lib/ruby/gems/1.9.1/gems/passenger"
 
   SOFTWARE                = [ REDIS, SQLITE3, RUBY, NGINX ]

data/installer/utils/delete_from_s3.rb

@@ -9,7 +9,6 @@ USER_DATA = `wget -q -O - http://169.254.169.254/latest/user-data`.split("\n")
 
 bucket_name = ARGV[0].strip
 channel     = ARGV[1].strip
-files = []
 
 def get_access_keys
   access_key        = USER_DATA[0].to_s.strip
@@ -20,11 +19,9 @@ end #get_access_keys
 
 AWS::S3::Base.establish_connection!(get_access_keys)
 
-objects = Bucket.objects(bucket_name)
-
-objects.each do |obj|
-  files << "#{obj.key}" if obj.key =~ /^#{channel}/
-end
+objects = Bucket.objects(bucket_name, :prefix => channel)
+files = []
+objects.each { |obj| files << "#{obj.key}" }
 
 files.each do |file|
   puts "Deleting #{file}"

data/installer/utils/download_from_s3.rb

@@ -9,7 +9,6 @@ USER_DATA = `wget -q -O - http://169.254.169.254/latest/user-data`.split("\n")
 
 bucket_name = 'rhoconnect'
 channel     = ARGV[0]
-files       = []
 
 exit if ARGV.length != 1
 
@@ -21,16 +20,13 @@ end #cmd
 def get_access_keys
   access_key        = USER_DATA[0].to_s.strip
   secret_access_key = USER_DATA[1].to_s.strip
-  keys = { :access_key_id => access_key,
-           :secret_access_key => secret_access_key}
-end #get_access_keys
+  keys = { :access_key_id => access_key, :secret_access_key => secret_access_key}
+end
 
 AWS::S3::Base.establish_connection!(get_access_keys)
-
-objects = Bucket.objects(bucket_name)
-objects.each do |obj|
-  files << "#{obj.key}" if obj.key =~ /^#{channel}/
-end
+objects = Bucket.objects(bucket_name, :prefix => channel)
+files = []
+objects.each { |obj| files << "#{obj.key}" }
 
 # Remove the files before downloading new in case they already exist
 cmd "rm -rf #{channel}" if File.directory? channel

data/installer/utils/verify_checksum.rb

@@ -25,25 +25,30 @@ dir_to_compare = ARGV[1]
 
 # Downoad Packages from S3
 cmd "ruby ./installer/utils/download_from_s3.rb #{dir_to_compare}"
-
 # Create the checksum to compare against the one from the S3 repo
 cmd "ruby ./installer/utils/create_sha1.rb #{dir_to_compare} ."
+old_sha1_h = YAML.load(File.read(checksum_hash))
+new_sha1_h = YAML.load(File.read("./sha1_hash"))
+
+match = true
+old_sha1_h.each do |k,v|
+  unless new_sha1_h[k]
+    puts "Error! Checksum mismatch for file #{v}"
+    match = false
+  end
+end
 
-old_sha1_h = YAML.load(File.read(checksum_hash)) 
-new_sha1_h = YAML.load(File.read("./sha1_hash")) 
-
-if checksum(old_sha1_h.keys) != checksum(new_sha1_h.keys) 
+unless match
+  puts
   puts "Checksums do not match!"
-
   puts "Expected sha1/file"
-  old_sha1_h = YAML.load(File.read(checksum_hash)).sort 
+  old_sha1_h = YAML.load(File.read(checksum_hash)).sort
   old_sha1_h.each { |k,v| puts "#{k}: #{v}" }
-
   puts "Got sha1/file"
-  new_sha1_h = YAML.load(File.read("./sha1_hash")).sort 
+  new_sha1_h = YAML.load(File.read("./sha1_hash")).sort
   new_sha1_h.each { |k,v| puts "#{k}: #{v}" }
-
+  puts
   exit 2
-end  
+end
 
 puts "Checksums match!"

data/js-adapters/ballroom.js

@@ -19,6 +19,15 @@ var _m_name = null;
 //TODO: Don't have test-specific code here
 var prefixDir = '/spec/apps/rhotestapp';
 
+//TODO: This has to be changed in the future
+// The only reason for this - on Windows Node.js
+// dies and leaves hanging opened sockets
+// Proper way: have a global domain as a safety valve
+process.on('uncaughtException', function(err) {
+  client_sub.quit();
+  client_pub.quit();
+});
+
 var controllerName = function(n){
   _c_name = n;
   registeredControllers[_c_name] = {};

data/js-adapters/exceptions.js

@@ -0,0 +1,60 @@
+var util = require('util');
+
+//Setup exception handlers
+var AbstractException = function (resp,msg,constr) {
+  Error.captureStackTrace(this, constr || this);
+  this.message = msg || 'Error';
+  resp.exception = {"error": {"error_type": this.name, "message": this.message, "stacktrace": this.stack} };
+  resp.send(null);
+};
+
+var Exception = function (resp,msg) {
+  Exception.super_.call(this, resp, msg, this.constructor);
+};
+
+var LoginException = function (resp,msg) {
+  LoginException.super_.call(this, resp, msg, this.constructor);
+};
+
+var LogoffException = function (resp,msg) {
+  LogoffException.super_.call(this, resp, msg, this.constructor);
+};
+
+var ServerTimeoutException = function (resp,msg) {
+  ServerTimeoutException.super_.call(this, resp, msg, this.constructor);
+};
+
+var ServerErrorException = function (resp,msg) {
+  ServerErrorException.super_.call(this, resp, msg, this.constructor);
+};
+
+var ObjectConflictErrorException = function (resp,msg) {
+  ObjectConflictErrorException.super_.call(this, resp, msg, this.constructor);
+};
+
+// Setup the types for each exception
+util.inherits(AbstractException, Error);
+util.inherits(Exception, AbstractException);
+util.inherits(LoginException, AbstractException);
+util.inherits(LogoffException, AbstractException);
+util.inherits(ServerTimeoutException, AbstractException);
+util.inherits(ServerErrorException, AbstractException);
+util.inherits(ObjectConflictErrorException, AbstractException);
+
+
+// Default names
+AbstractException.prototype.name            = 'AbstractException';
+Exception.prototype.name                    = 'Exception';
+LoginException.prototype.name               = 'LoginException';
+LogoffException.prototype.name              = 'LogoffException';
+ServerTimeoutException.prototype.name       = 'ServerTimeoutException';
+ServerErrorException.prototype.name         = 'ServerErrorException';
+ObjectConflictErrorException.prototype.name = 'ObjectConflictErrorException';
+
+// Public exceptions
+module.exports.Exception                    = Exception;
+module.exports.LoginException               = LoginException;
+module.exports.LogoffException              = LogoffException;
+module.exports.ServerTimeoutException       = ServerTimeoutException;
+module.exports.ServerErrorException         = ServerErrorException;
+module.exports.ObjectConflictErrorException = ObjectConflictErrorException;

data/js-adapters/node.rb

@@ -7,7 +7,7 @@ module Rhoconnect
     @started = false
     @pipe = nil
 
-    def self.shell_node
+    def self.shell_node(opts = {})
       package_file = File.join(Dir.pwd,'package.json')
       if not File.exists?(package_file)
         Rhoconnect.use_node = false
@@ -18,7 +18,7 @@ module Rhoconnect
       if which("node")
         begin
           if @started
-            kill_process
+            kill_process(opts)
           end
           @started = true
           dir  = File.expand_path(File.dirname(__FILE__))
@@ -28,7 +28,7 @@ module Rhoconnect
           file = File.join(dir,"server.js")
           args = [sub_env, "node", file, "#{$$}", Rhoconnect.environment.to_s]
           @pipe = IO.popen(args)
-          log "Started Node.js process: #{@pipe.pid}"
+          log "Starting Node.js process: #{@pipe.pid}"
           @pipe
         rescue Exception=>e
           puts "Node.js startup error: #{e.message}\n"
@@ -41,9 +41,18 @@ module Rhoconnect
       end
     end
 
-    def self.kill_process
+    def self.kill_process(opts = {})
       log "Stopping Node.js process: #{@pipe.pid}" if @pipe
-      NodeChannel.exit_node
+      if opts[:force]
+        begin
+          Process.kill('KILL', @pipe.pid)
+          Process.waitpid(@pipe.pid)
+        rescue
+          # Process not found, don't worry about killing it
+        end
+      else
+        NodeChannel.exit_node
+      end
       @started = false
       @pipe = nil
     end

data/js-adapters/node_channel.rb

@@ -11,7 +11,7 @@ module Rhoconnect
     TIMEOUT              = 30 # seconds
     PUB_CHANNEL          = "#{$$}RedisSUB" # pub channel must link to redis sub channel
     SUB_CHANNEL          = "#{$$}RedisPUB" # sub channel must link to redis pub channel
-    @message_thread,@redis,@redis2 = nil
+    @message_thread,@redis_subscriber,@redis_publisher = nil
 
     class << self
       attr_accessor :thrd, :register_semaphore, :register_condition
@@ -20,22 +20,22 @@ module Rhoconnect
         TIMEOUT
       end
 
-      def redis
+      def redis_subscriber
         url = Rhoconnect.redis.is_a?(Array) ? Rhoconnect.redis[0] : Rhoconnect.redis
         db_inst = RedisImpl.new
         db_inst.create(url)
-        @redis ||= db_inst.db
+        @redis_subscriber ||= db_inst.db
       end
 
-      def redis2
+      def redis_publisher
         url = Rhoconnect.redis.is_a?(Array) ? Rhoconnect.redis[0] : Rhoconnect.redis
         db_inst = RedisImpl.new
         db_inst.create(url)
-        @redis2 ||= db_inst.db
+        @redis_publisher ||= db_inst.db
       end
 
       def exit_node
-        NodeChannel.redis2.publish(PUB_CHANNEL,{:route => 'deregister'}.to_json)
+        NodeChannel.redis_publisher.publish(PUB_CHANNEL,{:route => 'deregister'}.to_json)
       end
 
       def bootstrap
@@ -54,58 +54,85 @@ module Rhoconnect
       end
 
       def publish_channel_and_wait(msg,curr_model)
-        unique_id = UUIDTools::UUID.random_create.to_s.gsub(/\-/,"")
+        unique_id = get_random_uuid
         msg.merge!(:request_id => unique_id)
         RESULT_HASH[unique_id] = {}
         RESULT_HASH[unique_id][:status] = 'waiting'
-        NodeChannel.redis2.publish(PUB_CHANNEL,msg.to_json)
-        NodeChannel.wait_for_result(unique_id,curr_model)
+        publish_channel(PUB_CHANNEL,msg,unique_id,curr_model)
       end
 
       def check_channel
-        NodeChannel.redis.subscribe(SUB_CHANNEL) do |on|
+        NodeChannel.redis_subscriber.subscribe(SUB_CHANNEL) do |on|
           on.message do |channel,msg|
             m = JSON.parse(msg)
-            #puts "received message: #{m.inspect}"
             if m['exit'] == true
-              NodeChannel.redis.unsubscribe
+              NodeChannel.redis_subscriber.unsubscribe
             end
             route_message(m)
           end
         end
       end
 
-      def publish_channel(msg)
-        NodeChannel.redis2.publish(PUB_CHANNEL,msg.to_json)
+      def publish_channel(channel,msg,unique_id = nil,curr_model = nil)
+        result = {}
+        num_clients = NodeChannel.redis_publisher.publish(channel,msg.to_json)
+        if num_clients >= 1
+          result = NodeChannel.wait_for_result(unique_id,curr_model) if unique_id and curr_model
+        else
+          log "ERROR: Cannot communicate with Node.js process."
+          if Rhoconnect.restart_node_on_error
+            t = Thread.new do
+              # Shutdown our ruby subscription by issuing redis channel instruction
+              NodeChannel.redis_subscriber.publish(SUB_CHANNEL,{'exit' => true}.to_json)
+            end
+            t.join
+            Rhoconnect.start_nodejs_channels(force: true)
+          end
+        end
+        result
       end
 
       def wait_for_result(key,curr_model)
         begin
           Timeout::timeout(TIMEOUT) do
             while(RESULT_HASH[key][:status] == 'waiting') do
-              if data = RESULT_HASH[key][:process_request]
+              if RESULT_HASH[key][:pending_js_requests] and result_id = RESULT_HASH[key][:pending_js_requests][0]
                 #do some logic and return data with memory
-
-                RESULT_HASH[key][:process_result]  = process_message(curr_model,data)
-                RESULT_HASH[key][:process_request] = nil
-              else
-                sleep 0.001
+                data = RESULT_HASH[key][result_id][:process_request]
+                msg_result = process_message(curr_model,data)
+                RESULT_HASH[key][result_id][:process_result]  = msg_result
+                RESULT_HASH[key][:pending_js_requests] = RESULT_HASH[key][:pending_js_requests].drop(1)
+                if RESULT_HASH[key][:pending_js_requests].length == 0 and not RESULT_HASH[key][:result].nil?
+                  RESULT_HASH[key][:status] = 'done'
+                end
+                publish_channel(PUB_CHANNEL,msg_result)
               end
+              Thread.pass
             end
           end
         rescue Exception=>e
           RESULT_HASH[key][:status] = 'broken'
           RESULT_HASH[key][:result] = "exception #{e.message}\n#{e.backtrace}"
-          log "Timeout on wait, setting JavaScript result state to broken: #{e.inspect}"
+          log "Timeout on wait, setting JavaScript result state to broken: #{e.message}"
           log e.backtrace.join("\n")
         end
-
         #request waiting either timed out or returned response
+        res = {}
         if RESULT_HASH[key][:status] == 'broken' or  RESULT_HASH[key][:status] == 'waiting'
           res = RESULT_HASH.delete(key)
-        elsif RESULT_HASH[key] =~ /JS ERROR/
-          res = RESULT_HASH.delete(key)
-          raise Exception.new(res)
+        elsif RESULT_HASH[key] and RESULT_HASH[key][:result].is_a?(Hash) and RESULT_HASH[key][:result]['error_type']
+          include Rhoconnect::Model
+          res = RESULT_HASH.delete(key)[:result]
+          klass = res['error_type']
+          exception = nil
+
+          if klass and const_defined?(klass)
+            exception = const_get(klass).new(res['message'])
+          else
+            exception = Exception.new(res['message'])
+          end
+          exception.set_backtrace(res['stacktrace'].split("\n"))
+          raise exception
         else
           res = RESULT_HASH.delete(key)
         end
@@ -115,25 +142,31 @@ module Rhoconnect
       def route_message(msg)
         case msg['route']
         when 'request'
-          RESULT_HASH[msg['request_id']][:process_result]  = 'waiting'
-          RESULT_HASH[msg['request_id']][:process_request] = msg
-          wait_for_process_result(msg['request_id'])
+          result_id = get_random_uuid
+          RESULT_HASH[msg['request_id']][:pending_js_requests] ||= []
+          RESULT_HASH[msg['request_id']][:pending_js_requests] << result_id
+          RESULT_HASH[msg['request_id']][result_id] = {}
+          RESULT_HASH[msg['request_id']][result_id][:process_result]  = 'waiting'
+          RESULT_HASH[msg['request_id']][result_id][:process_request] = msg
         when 'response'
           return if RESULT_HASH[msg['request_id']] == nil
           if msg['error'] and msg['error'].size > 1
-            RESULT_HASH[msg['request_id']][:result] = "JS ERROR: #{msg['error']}"
+            RESULT_HASH[msg['request_id']][:result] = msg['error']
             RESULT_HASH[msg['request_id']][:status] = 'done'
           else
             RESULT_HASH[msg['request_id']][:result] = msg["result"]
-            RESULT_HASH[msg['request_id']][:status] = 'done'
+            pending_js_requests = RESULT_HASH[msg['request_id']][:pending_js_requests]
+            if not pending_js_requests or pending_js_requests.length == 0 
+              RESULT_HASH[msg['request_id']][:status] = 'done'
+            end
           end
         when 'register'
           @register_semaphore.synchronize do
             begin
               register_routes(msg)
             rescue Exception => e
-              puts "Error registering JavaScript routes: #{e.inspect}"
-              puts e.backtrace.join("\n")
+              log "Error registering JavaScript routes: #{e.inspect}"
+              log e.backtrace.join("\n")
               raise e
             ensure
               @register_condition.signal
@@ -142,25 +175,14 @@ module Rhoconnect
         end
       end
 
-      def wait_for_process_result(key)
-        Timeout::timeout(TIMEOUT){
-          while(RESULT_HASH[key][:process_result] == 'waiting') do
-            sleep 0.001
-          end
-        }
-        publish_channel(RESULT_HASH[key][:process_result])
-      end
-
       def process_message(curr_model,data)
-        # puts "proccessing msg #{data.inspect}"
         klass = curr_model
         klass = Object.const_get(data['kls']) if data['kls']
         if klass.respond_to?(data['function'].to_sym)
           if data['args'] and data['args'].size > 0
             if(data['function'] == 'stash_result')
               klass.send('result=',data['args'])
-              klass.send(data['function'])
-              process_res = nil
+              res = klass.send(data['function'])
             else
               res = klass.send(data['function'],*data['args'])
             end
@@ -171,12 +193,10 @@ module Rhoconnect
           raise Exception.new("Method #{data['function']} not found in model #{curr_model.class.name.to_s}.")
         end
 
-        process_res = res
         unless res.is_a?(String) or res.is_a?(TrueClass) or res.is_a?(FalseClass) or res.nil?
-          process_res = res.to_hash
+          res = res.to_hash
         end
-
-        {:result=>process_res,:callback=>data['callback'],:request_id=>data['request_id'],:route=>'response'}
+        {:result=>res,:callback=>data['callback'],:request_id=>data['request_id'],:route=>'response'}
       end
 
       def register_routes(hsh)