rhoconnect 3.4.5 → 4.0.0.beta.10

data/install.sh

@@ -46,7 +46,7 @@ checkDeps ()
 }
 
 # determinePkgMgr
-# Determines if the system is currently using rpm or
+# Determines if the system is currently using rpm or 
 # debian based pckage management
 determinePkgMgr ()
 {
@@ -195,7 +195,7 @@ installRuby ()
     echo "tar -xzf ${prefix}/${rubyTar} -C ${prefix}" >> $log
     tar -xzf ${prefix}/${rubyTar} -C ${prefix} > /dev/null 2>&1
   fi
-
+  
   echo "Installing ruby. This may take some time..." | tee -a $log
   echo "pushd ${prefix}/${rubyDir}" | tee -a $log
   pushd ${prefix}/${rubyDir}
@@ -204,14 +204,14 @@ installRuby ()
   echo "make && make install" | tee -a $log
   make >> $log 2>&1
   make install >> $log 2>&1
-
+  
   if (( $? )) ; then
     echo "Some dependencies not installed..." | tee -a $log
     echo "Please install them and then re-run the installation script." | tee -a $log
     echo "For troubleshooting see file $log ..." | tee -a $log
     exit 1
   fi
-
+  
   popd
   echo -e "$rubyDir is successfully installed.\n" | tee -a $log
 }
@@ -293,7 +293,7 @@ fi
 # Install redis, sqllite3, nginx, rhoconnect
 opts=" -d $dist -l $log"
 ${prefix}/bin/ruby ${INSTALL_DIR}/unix-like/rhoinstaller.rb ${opts}
-if (( $? )) ; then
+if (( $? )) ; then 
   echo "Installation failed. For troubleshooting see file $log ..." | tee -a $log
   exit 1
 fi

data/installer/unix-like/create_texts.rb

@@ -725,10 +725,10 @@ _NGINX_TO_DO_
     else
       server_todo_list = <<_NGINX_TO_DO_
 2) Try rhoconnect 'rhoapp' application, created in /opt/nginx/html directory
-  A) As root user start redis, nginx and thin servers:
+  A) As root user start redis, thin and nginx servers:
      /etc/init.d/redis start
-     /etc/init.d/nginx start
      /etc/init.d/thin start
+     /etc/init.d/nginx start
   B) Open RhoConnect application web console in your browser:
      http://servername
 

data/installer/unix-like/rho_connect_install_constants.rb

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

data/installer/unix-like/rho_connect_install_utilities.rb

@@ -41,7 +41,7 @@ module Utilities
   # This method moves all compressed files from the installation directory
   # that were downloaded by this installation process
   def cleanup(prefix)
-    #print_header "Cleaning up ..."
+    print_header "Cleaning up ..."
     Constants::SOFTWARE.each do |sw|
       cmd "rm #{prefix}/#{sw}.tar.gz; rm -rf #{prefix}/#{sw}" if File.exist? "#{prefix}/#{sw}.tar.gz"
     end

data/installer/utils/constants.rb

@@ -12,19 +12,19 @@ module Constants
   SSH_KEY         = "#{HOME_DIR}/.ssh/#{PEM_FILE}"
   ACCESS_KEY_FILE = "#{HOME_DIR}/.ec2"
   UBUNTU_STACK    = { :image_id  => 'ami-02d7f547', # jenkins-ubuntu-12.04-test-image
-                      :tags => {'Name' => 'Ubuntu-12.04'},
+                      :tags => {'Name' => 'Ubuntu-12.04'}, 
                       :flavor_id => 'c1.xlarge',
                       :key_name  => 'jenkinskey',
                       :groups    => 'load-test',
                       :user      => 'ubuntu'}
-  CENTOS5_STACK   = { :image_id  => 'ami-bed9f5fb', # jenkins-centos-5.9-test-image
-                      :tags => {'Name' => 'CentOS-5.9'},
+  CENTOS5_STACK   = { :image_id  => 'ami-6aaf8d2f', # jenkins-centos-5.9-test-image
+                      :tags => {'Name' => 'CentOS-5.9'}, 
                       :flavor_id => 'c1.xlarge',
                       :key_name  => 'jenkinskey',
                       :groups    => 'load-test',
                       :user      => 'root'}
   CENTOS6_STACK   = { :image_id  => 'ami-02ae8c47', # jenkins-centos-6.3-test-image
-                      :tags => {'Name' => 'CentOS-6.3'},
+                      :tags => {'Name' => 'CentOS-6.3'}, 
                       :flavor_id => 'c1.xlarge',
                       :key_name  => 'jenkinskey',
                       :groups    => 'load-test',

data/js-adapters/ballroom.js

@@ -0,0 +1,216 @@
+var redis = require('redis'),
+    fs = require('fs'),
+    util = require('util'),
+    EventEmitter = require('events').EventEmitter,
+    registerEE = new EventEmitter(),
+    routes = require('./router'),
+    client_sub = redis.createClient(),
+    client_pub = redis.createClient(),
+    pub_channel = process.argv[2] + "RedisPUB";
+
+//define global hash functions to store callbacks, routes
+rhoconnectCallbacks = {};
+registeredRoutes = {};
+registeredControllers = {};
+registeredModels = {};
+var _c_name = null;
+var _m_name = null;
+//TODO: Don't have test-specific code here
+var prefixDir = '/spec/apps/rhotestapp';
+
+var controllerName = function(n){
+  _c_name = n;
+  registeredControllers[_c_name] = {};
+  registeredControllers[_c_name]['routes'] = [];
+  registeredControllers[_c_name]['defaults'] = [];
+  this.modelName(_c_name);
+};
+
+var modelName = function(n){
+  // TODO: Need to map directly to registeredModels
+  registeredControllers[_c_name]['model'] = n;
+};
+
+var exitNodejs = function(){
+  send({"exit": true});
+  process.exit(0);
+};
+
+var listen = function(channel){
+  client_sub.subscribe(channel);
+  client_sub.on("message", function(channel, message) {
+    //console.error("message nodejs recvd:" + message)
+    var json = JSON.parse(message);
+    try{
+      routes.router(json,send);
+    }
+    catch(e){
+      console.error("Node.js error caught: "+ e);
+      console.error("Backtrace: " + e.stack);
+    }
+  });
+};
+
+var send = function(json){
+  if(json['callback']){
+    var h_id = guid();
+    rhoconnectCallbacks[h_id] = json['callback'];
+    json['callback'] = h_id;
+  }
+  var j = JSON.stringify(json);
+  client_pub.publish(pub_channel,j);
+};
+
+var registerHandler = function(name) {
+  switch(name){
+    case 'sync':
+      this.defaults(
+        {
+          admin_required: false,
+          login_required: true,
+          source_required: true,
+          client_required: true
+        }
+      );
+
+      this.get('/', {"rc_handler":"query",
+        "deprecated_route": {"verb": "get", "url": ['/api/application', '/application', '/api/application/query']}}, function(req,resp){
+        loadModel(req.model).query(resp);
+      });
+
+      this.post('/', {"rc_handler":"cud",
+        "deprecated_route": {"verb": "post", "url": ['/api/application', '/application', '/api/application/queue_updates']}}, function(req,resp){
+        var operationCall = req.params.operation;
+        if(operationCall === 'delete') {
+          operationCall = 'del';
+        }
+        loadModel(req.model)[operationCall](resp);
+      });
+
+      this.put('/:id', {"rc_handler":"update"}, function(req,resp){
+        loadModel(req.model).update(resp);
+      });
+
+      this.del('/:id', {"rc_handler":"delete"}, function(req,resp){
+        loadModel(req.model).del(resp);
+      });
+      break;
+    default: break;
+  }
+};
+
+var register = function(){
+  var controller_dir = "";
+  var model_dir = "";
+  try{
+    if(process.argv[3] == 'test' ){
+      controller_dir = process.cwd() + prefixDir + "/controllers/js/";
+      model_dir = process.cwd() + prefixDir + "/models/js/";
+    }
+    else{
+      controller_dir = process.cwd() + "/controllers/js/";
+      model_dir = process.cwd() + "/models/js/";
+    }
+    if(fs.existsSync(model_dir)){
+      var modelFiles = fs.readdirSync(model_dir);
+      modelFiles.forEach(function(file){
+        //console.error("requiring model file: " + file);
+        var model = require(model_dir + file);
+        var functions = Object.keys(model);
+        mapModelFunctions(file.split(".")[0],functions);
+      });
+    }
+    if(fs.existsSync(controller_dir)){
+      var controllerFiles = fs.readdirSync(controller_dir);
+      controllerFiles.forEach(function(file){
+        //console.error("requiring controller file: " + file);
+        require(controller_dir + file);
+        _c_name = null;
+      });
+    }
+  }
+  catch(e){
+    console.error("Error loading JavaScript files.");
+    throw(e);
+  }
+  registerEE.emit('register_complete');
+};
+
+// this event will be called when all files have been registered
+registerEE.on('register_complete',function(){
+  var json = {};
+  json['route'] = 'register';
+  json['result'] = registeredControllers;
+  json['models'] = registeredModels;
+  send(json);
+});
+
+
+var get = function(url,options,callback){
+  var key = 'get_rjs_' + _c_name + '_rjs_' + url + '_rjs_' + format_options(options);
+  registeredRoutes[key] = callback;
+  registeredControllers[_c_name]['routes'].push(key);
+};
+
+var post = function(url,options,callback){
+  var key = 'post_rjs_'  + _c_name + '_rjs_' + url + '_rjs_' + format_options(options);
+  registeredRoutes[key] = callback;
+  registeredControllers[_c_name]['routes'].push(key);
+};
+
+var put = function(url,options,callback){
+  var key = 'put_rjs_'  + _c_name + '_rjs_' + url + '_rjs_' + format_options(options);
+  registeredRoutes[key] = callback;
+  registeredControllers[_c_name]['routes'].push(key);
+};
+
+var del = function(url,options,callback){
+  var key = 'delete_rjs_'  + _c_name + '_rjs_' + url + '_rjs_' + format_options(options);
+  registeredRoutes[key] = callback;
+  registeredControllers[_c_name]['routes'].push(key);
+};
+
+var defaults = function(hsh){
+  registeredControllers[_c_name]['defaults'].push(hsh);
+};
+
+var format_options = function(opts){
+  return JSON.stringify(opts);
+  // var f_opts = "";
+  // for(var propt in opts){
+  //   f_opts += propt + ":" + opts[propt];
+  // }
+  // return f_opts;
+};
+
+function guid() {
+    return (((1+Math.random())*0x100000000)|0).toString(16).substring(1);
+}
+
+function mapModelFunctions(model,functions){
+  registeredModels[model] = [];
+  for(var i = 0;i< functions.length;i++){
+    registeredModels[model].push(functions[i]);
+  }
+}
+
+function loadModel(name) {
+  var prefix = process.cwd();
+  if(process.argv[3] === 'test') {
+    prefix = prefix + prefixDir;
+  }
+  return require(prefix + "/models/js/" + name);
+}
+
+exports.controllerName = controllerName;
+exports.modelName = modelName;
+exports.register = register;
+exports.registerHandler = registerHandler;
+exports.send = send;
+exports.listen = listen;
+exports.get = get;
+exports.put = put;
+exports.del = del;
+exports.post = post;
+exports.defaults = defaults;
+exports.exitNodejs = exitNodejs;

data/js-adapters/node.rb

@@ -0,0 +1,52 @@
+module Rhoconnect
+  class Node
+
+    class << self
+      attr_accessor :started,:pipe
+    end
+    @started = false
+    @pipe = nil
+
+    def self.shell_node
+      package_file = File.join(Dir.pwd,'package.json')
+      if not File.exists?(package_file)
+        Rhoconnect.use_node = false
+        log "No `package.json` detected, disabling JavaScript support."
+        return
+      end
+
+      if which("node")
+        begin
+          if @started
+            kill_process
+          end
+          @started = true
+          dir  = File.expand_path(File.dirname(__FILE__))
+          pwd = Dir.pwd
+          node_modules = File.join(pwd,'node_modules')
+          sub_env = { "NODE_PATH" => "#{node_modules}#{File::PATH_SEPARATOR}#{pwd}#{File::PATH_SEPARATOR}#{dir}" }
+          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}"
+          @pipe
+        rescue Exception=>e
+          puts "Node.js startup error: #{e.message}\n"
+          puts e.backtrace.join("\n")
+          raise e
+        end
+      else
+        Rhoconnect.use_node = false
+        log "Node.js not detected, disabling JavaScript support."
+      end
+    end
+
+    def self.kill_process
+      log "Stopping Node.js process: #{@pipe.pid}" if @pipe
+      NodeChannel.exit_node
+      @started = false
+      @pipe = nil
+    end
+
+  end
+end

data/js-adapters/node_channel.rb

@@ -0,0 +1,181 @@
+require 'timeout'
+require 'open-uri'
+module Rhoconnect
+  class NodeChannel
+    class << self
+      attr_accessor :redis,:redis2,:message_thread
+      @message_thread = nil
+    end
+
+    RESULT_HASH          = {}
+    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
+
+    class << self
+      attr_accessor :thrd, :register_semaphore, :register_condition
+
+      def get_timeout
+        TIMEOUT
+      end
+
+      def redis
+        url = Rhoconnect.redis.is_a?(Array) ? Rhoconnect.redis[0] : Rhoconnect.redis
+        db_inst = RedisImpl.new
+        db_inst.create(url)
+        @redis ||= db_inst.db
+      end
+
+      def redis2
+        url = Rhoconnect.redis.is_a?(Array) ? Rhoconnect.redis[0] : Rhoconnect.redis
+        db_inst = RedisImpl.new
+        db_inst.create(url)
+        @redis2 ||= db_inst.db
+      end
+
+      def exit_node
+        NodeChannel.redis2.publish(PUB_CHANNEL,{:route => 'deregister'}.to_json)
+      end
+
+      def bootstrap
+        @register_semaphore ||= Mutex.new
+        @register_condition ||= ConditionVariable.new
+        # Run in the main thread, we setup node thread and wait for it to
+        # finish bootstrapping before main thread can continue
+        if @message_thread
+          @message_thread.join
+          @message_thread = nil
+        end
+        @register_semaphore.synchronize do
+          @message_thread = Thread.new{check_channel}
+          @register_condition.wait(@register_semaphore)
+        end
+      end
+
+      def publish_channel_and_wait(msg,curr_model)
+        unique_id = UUIDTools::UUID.random_create.to_s.gsub(/\-/,"")
+        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)
+      end
+
+      def check_channel
+        NodeChannel.redis.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
+            end
+            route_message(m)
+          end
+        end
+      end
+
+      def publish_channel(msg)
+        NodeChannel.redis2.publish(PUB_CHANNEL,msg.to_json)
+      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]
+                #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
+              end
+            end
+          end
+        rescue Exception=>e
+          RESULT_HASH[key][:status] = 'broken'
+          RESULT_HASH[key][:result] = "exception #{e.message}\n#{e.backtrace}"
+          puts "Timeout on wait, setting JavaScript result state to broken: #{e.inspect}"
+        end
+
+        #request waiting either timed out or returned response
+        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)
+        else
+          res = RESULT_HASH.delete(key)
+        end
+        res[:result]
+      end
+
+      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'])
+        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']][:status] = 'done'
+          else
+            RESULT_HASH[msg['request_id']][:result] = msg["result"]
+            RESULT_HASH[msg['request_id']][:status] = 'done'
+          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")
+              raise e
+            ensure
+              @register_condition.signal
+            end
+          end
+        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}"
+        if curr_model.respond_to?(data['function'])
+          if data['args'] and data['args'].size > 0
+            if(data['function'] == 'stash_result')
+              curr_model.send('result=',data['args'])
+              curr_model.send(data['function'])
+              process_res = nil
+            else
+              res = curr_model.send(data['function'],data['args'])
+            end
+          else
+            res = curr_model.send(data['function'])
+          end
+        else
+          raise Exception.new("Method #{data['function']} not found in model #{curr_model.class.name.to_s}.")
+        end
+
+        process_res = res.is_a?(String) ? res : res.to_hash if res
+
+        {:result=>process_res,:callback=>data['callback'],:request_id=>data['request_id'],:route=>'response'}
+      end
+
+      def register_routes(hsh)
+        Rhoconnect::Controller::JsBase.register_routes(hsh)
+      end
+    end
+  end
+end

data/js-adapters/request.js

@@ -0,0 +1,27 @@
+var Request = function(){	
+	this.__defineGetter__("params",function(){
+		return params; 
+	});
+	
+	this.__defineSetter__("params",function(arg){
+		params = arg;
+	});
+	
+	this.__defineGetter__("header",function(){
+		return header;
+	});
+	
+	this.__defineSetter__("header",function(arg){
+		header = arg;
+	});
+		
+	this.__defineGetter__("model",function(){
+		return model;
+	});
+
+	this.__defineSetter__("model",function(arg){
+		model = arg;
+	});
+	
+}
+module.exports = Request;

data/js-adapters/response.js

@@ -0,0 +1,57 @@
+Object.extend = function(destination, source) {
+    for (var property in source) {
+        if (source.hasOwnProperty(property)) {
+            destination[property] = source[property];
+        }
+    }
+    return destination;
+};
+
+var Response = function(){
+	var exception = "";
+
+	this.__defineGetter__("params",function(){
+		return params;
+	});
+
+	this.__defineSetter__("params",function(arg){
+		params = arg;
+	});
+
+	this.__defineGetter__("header",function(){
+		return header;
+	});
+
+	this.__defineSetter__("header",function(arg){
+		header = arg;
+	});
+
+	this.__defineGetter__("exception",function(){
+		return exception;
+	});
+
+	this.__defineSetter__("exception",function(arg){
+		exception = arg;
+	});
+
+	this.send = function(data){
+		var ballroom = require("./ballroom");
+		var user_json = {};
+
+		//if callback we are sending request to ruby
+		if(data['callback']){
+			this.params = null;
+			this.header['route'] = 'request';
+			user_json = data;
+		}
+		else{
+			user_json["result"] = data;
+		}
+
+		Object.extend(user_json,this.params);
+		Object.extend(user_json,this.header);
+		Object.extend(user_json,this.exception);
+		ballroom.send(user_json);
+	};
+};
+module.exports = Response;