rhoconnect 4.0.4 → 5.1.1

data/installer/unix-like/rho_connect_install_installers.rb

@@ -19,18 +19,18 @@ module Installers
     end
     raise "Nginx installation failed." if $? != 0
   end
-      
+
   def install_all_gems
     @gem_path = "#{@options[:prefix]}/bin/gem"
     # Update the RubyGems system software
     # FIXME: => v.2.0.0
-    cmd "#{@gem_path} update --system 1.8.25"
+    # cmd "#{@gem_path} update --system 1.8.25"
     GEMS.each do |gem|
       install_gem(gem)
     end
   end
 
-  def install_gem(gem, options = "--no-ri --no-rdoc")
+  def install_gem(gem, options = "--no-document")
     print_header "Installing #{gem} ..."
     cmd "#{@gem_path} install #{gem} #{options}"
     raise "#{gem} installation failed." if $? != 0
@@ -76,7 +76,7 @@ module Installers
 
     cmd "#{@options[:prefix]}/bin/bundle config build.sqlite3 " +
         "--with-sqlite3-include=#{@options[:prefix]}/include " +
-        "--with-sqlite3-lib=#{@options[:prefix]}/lib" 
+        "--with-sqlite3-lib=#{@options[:prefix]}/lib"
     gem_name = (Dir.glob "rhoconnect-*.gem")[0]
     if gem_name && File.exists?(gem_name)
       install_gem(gem_name)

data/installer/utils/constants.rb

@@ -11,20 +11,20 @@ module Constants
   PEM_FILE        = 'jenkinskey.pem'
   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'},
+  UBUNTU_STACK    = { :image_id  => 'ami-e0b882a5', # jenkins-ubuntu-14.04-test-image
+                      :tags => {'Name' => 'Ubuntu-14.04'},
                       :flavor_id => 'c1.xlarge',
                       :key_name  => 'jenkinskey',
                       :groups    => 'load-test',
                       :user      => 'ubuntu'}
-  CENTOS5_STACK   = { :image_id  => 'ami-1a7d4d5f', # jenkins-centos-5.9-test-image
-                      :tags => {'Name' => 'CentOS-5.9'},
+  CENTOS5_STACK   = { :image_id  => 'ami-079b9d42', # jenkins-centos-5.10-test-image
+                      :tags => {'Name' => 'CentOS-5.10'},
                       :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'},
+  CENTOS6_STACK   = { :image_id  => 'ami-19283b5c', # jenkins-centos-6.6-test-image
+                      :tags => {'Name' => 'CentOS-6.6'},
                       :flavor_id => 'c1.xlarge',
                       :key_name  => 'jenkinskey',
                       :groups    => 'load-test',

data/installer/utils/nix_install_test.rb

@@ -16,7 +16,7 @@ def run_on_server(server, cmds)
   result = server.ssh(cmds)
   result.each do |r|
     raise "Command #{r.command} failed.\nStdout: #{r.stdout}\nStderr: #{r.stderr}" if r.status != 0
-    puts "$ #{r.command}" 
+    puts "$ #{r.command}"
     puts r.stdout
   end
 end
@@ -51,7 +51,7 @@ def compile_stack_info(stack)
               :local_file =>    "#{local_file}rhoconnect_#{Constants::RC_VERSION}_all.deb",
               :pkg_mgr =>       'dpkg',
               :pkg_type =>      'DEB',
-              :pkg_cmd =>       'apt-get',
+              :pkg_cmd =>       'apt-get --force-yes -y',
               :deps =>          Constants::DEB_DEPS,
               :repo_src_file => '/etc/apt/sources.list',
               :repo_str =>      '\n' +
@@ -81,22 +81,22 @@ def connect_to_amazon
   lines = IO.readlines Constants::ACCESS_KEY_FILE
   access_key        = lines.first.strip.split("=")[1]
   secret_access_key = lines.last.strip.split("=")[1]
-  
+
   Fog::Compute.new(:provider => 'AWS', :region => Constants::REGION,
-    :aws_access_key_id => access_key, 
-    :aws_secret_access_key => secret_access_key)    
+    :aws_access_key_id => access_key,
+    :aws_secret_access_key => secret_access_key)
 end
 
 # Creates a new ec2 instance as per the given stack.
 def start_new_instance(connection, params)
   puts "Creating new instance..."
 
-  server = connection.servers.create(params)  
+  server = connection.servers.create(params)
   # Wait for machine to be booted
   server.wait_for { ready? }
   # Wait for machine to get an ip-address
-  server.wait_for { !public_ip_address.nil? }  
-  
+  server.wait_for { !public_ip_address.nil? }
+
   if server.ready?
     # wait for all services to start on remote VM
     puts "Waiting #{Constants::SLEEP} seconds for services to start on remote VM..."
@@ -122,18 +122,18 @@ def install_package(server, distro_params)
   # Get current permissions of file
   perms = server.ssh("stat --format=%a #{filename}")[0].stdout.strip
   # Change permissions so that it can be edited by "others"
-  cmds = ["sudo chmod 0666 #{filename}", 
-          "echo -e \"#{src_str}\" >> #{filename}", 
+  cmds = ["sudo chmod 0666 #{filename}",
+          "echo -e \"#{src_str}\" >> #{filename}",
           "sudo chmod 0#{perms} #{filename}"]
-  cmds << "sudo #{distro_params[:pkg_cmd]} update" unless distro_params[:flavor] == "centos"  
-  run_on_server(server, cmds) 
+  cmds << "sudo #{distro_params[:pkg_cmd]} update" unless distro_params[:flavor] == "centos"
+  run_on_server(server, cmds)
 
   puts "Installing rhoconnect package.\nThis may take a while...\n\n"
-  run_on_server(server, "yes | sudo #{distro_params[:pkg_cmd]} install rhoconnect")
+  run_on_server(server, "sudo #{distro_params[:pkg_cmd]} install rhoconnect")
 end
 
 def start_services(server)
-  puts  
+  puts
   ['redis', 'thin', 'nginx'].each do |program|
     status = -1
 	  3.times do
@@ -183,7 +183,7 @@ def ping_remote_host(server)
     begin
       res = server.ssh(['uptime'])
       status = res[0].status
-      break if status == 0 
+      break if status == 0
     rescue Exception => e
       sleep 6
     end
@@ -194,23 +194,23 @@ end
 def test_package(connection, stack)
   start_time = Time.now
 
-  user, distro_params = compile_stack_info(stack)  
-  server = start_new_instance(connection, stack)  
+  user, distro_params = compile_stack_info(stack)
+  server = start_new_instance(connection, stack)
   host = server.dns_name
   puts "Remote host #{host} is up and running ..."
-   
+
   server.username = user
-  server.private_key_path = Constants::SSH_KEY    
+  server.private_key_path = Constants::SSH_KEY
   puts "Establish ssh connection for \"#{user}@#{host}\" ..."
-  # For a minute trying to reach remote host  
-  raise "Cannot establish ssh connection with #{stack[:tags]['Name']} instance." if ping_remote_host(server) != 0  
+  # For a minute trying to reach remote host
+  raise "Cannot establish ssh connection with #{stack[:tags]['Name']} instance." if ping_remote_host(server) != 0
   puts "SSH connection establised!"
 
   install_package(server, distro_params)
   # Start the redis and nginx servers on the remote machine
   start_services(server)
   # Check the status of the rhoconnect service
-  check_rhoconnect_status(server) 
+  check_rhoconnect_status(server)
 
   elapsed_time = (Time.now - start_time).to_i
   puts "Test for #{stack[:tags]['Name']} completed in #{elapsed_time/60} min. #{elapsed_time - ((elapsed_time/60)*60)} sec."
@@ -220,7 +220,7 @@ rescue => e
   puts e.backtrace
   -1
 ensure
-  if server 
+  if server
     puts "Terminating #{stack[:tags]['Name']} instance ..."
     server.destroy
   end
@@ -230,7 +230,7 @@ module ThreadOut
   # Writes to Thread.current[:stdout] instead of STDOUT if the thread local is set.
   def self.write(stuff)
     if Thread.current[:stdout] then
-      Thread.current[:stdout].write stuff 
+      Thread.current[:stdout].write stuff
     else
       STDOUT.write stuff
     end
@@ -252,7 +252,7 @@ STACK_SIZE.times do |i|
   threads << Thread.new(i) do |idx|
     puts "Starting test for #{STACKS[idx][:tags]['Name']} ... "
     Thread.current[:stdout] = logs[idx]
-    test_package(connection, STACKS[idx]) 
+    test_package(connection, STACKS[idx])
   end
 end
 # Wait till threads re finished
@@ -260,15 +260,15 @@ threads.each { |thread| thread.join }
 
 # Output logs and check resluts
 threads.each_with_index do |thread, i|
-  puts "\n#{STACKS[i][:tags]['Name']} installation log:" 
-  puts logs[i].string  
+  puts "\n#{STACKS[i][:tags]['Name']} installation log:"
+  puts logs[i].string
 end
 exit_code = 0
 threads.each_with_index do |thread, i|
   if thread.value != 0
-    puts "Package for #{STACKS[i][:tags]['Name']} failed to pass test!" 
+    puts "Package for #{STACKS[i][:tags]['Name']} failed to pass test!"
     exit_code = -1
-  end  
+  end
 end
 
 elapsed_time = (Time.now - start_at).to_i

data/installer/utils/package_upload/repos.rake

@@ -12,33 +12,23 @@ task "build:repos", :build_type, :build_number do |t, args|
   args.with_defaults :build_type   => 'nightly'
   args.with_defaults :build_number => ''
   puts args
-  
+
   build_type   = args[:build_type]
   build_number = args[:build_number]
 
-  # CONSTANTS
-
   RHOCONNECT_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..'))
-
-  PKG_DIR         = case build_type
-                    when 'release'
-                      '/packages'
-                    when 'test'
-                      '/test-packages'
-                    when 'beta'
-                      '/beta-packages'
-                    else 'nightly'
-                      '/nightly-packages'
-                    end #case
-
-  BUCKET          = 'rhoconnect'
+  PKG_DIR = case build_type
+            when 'release'  then '/packages'
+            when 'test'     then '/test-packages'
+            when 'beta'     then '/beta-packages'
+            else '/nightly-packages'
+            end
+  BUCKET = 'rhoconnect'
 
   def cmd(cmd)
     puts cmd
     puts `#{cmd}`
-  end #cmd
-
-  # METHODS
+  end
 
   def prepare_destination
     # Prompt to remove the /deb directory if it exists
@@ -61,7 +51,7 @@ task "build:repos", :build_type, :build_number do |t, args|
     cmd "sudo touch #{filename}/distributions"
     cmd "sudo chmod -R 777 #{PKG_DIR}"
 
-    # Write distributions string to corresponding file 
+    # Write distributions string to corresponding file
     dist_file = File.new("#{filename}/distributions", "w")
     dist_file.write(distributions)
     dist_file.close
@@ -71,7 +61,7 @@ task "build:repos", :build_type, :build_number do |t, args|
 
   end #prepare_destination
 
-  
+
   def copy_files
     # Move back into rhoconnect repo root first
     Dir.chdir RHOCONNECT_ROOT
@@ -96,13 +86,13 @@ task "build:repos", :build_type, :build_number do |t, args|
   prepare_destination
 
   copy_files
-  
+
  if !build_number.empty?
    # Change name of packages to include build number
   ['deb', 'rpm'].each do |arch|
     Find.find("#{PKG_DIR}") do |file|
       if !File.directory?(file) and file =~ /#{arch}$/
-        file_to_rename = File.open(file, 'r')
+        #file_to_rename = File.open(file, 'r')
         old_name = File.expand_path(file)
         new_name = old_name.gsub(/(#{arch})$/, "#{build_number}.\\1" )
         #File.rename(old_name, new_name)
@@ -117,14 +107,14 @@ task "build:repos", :build_type, :build_number do |t, args|
   # REPOIFY!
   cmd "sudo reprepro -b #{PKG_DIR}/deb includedeb rhoconnect #{PKG_DIR}/deb/#{@deb_pkg}"
   cmd "sudo createrepo #{PKG_DIR}/rpm"
-  
+
   # Create SHA1 checksum of repo dirs
-  checksum_dest = "#{PKG_DIR}/SHA1/"
+  # checksum_dest = "#{PKG_DIR}/SHA1/"
   cmd "sudo ./installer/utils/create_sha1.rb #{PKG_DIR} #{PKG_DIR}/SHA1"
 
   # Call s3_upload.rb
   ['deb', 'rpm'].each do |dir|
-    cmd "sudo ruby ./installer/utils/package_upload/s3_upload.rb #{PKG_DIR}/#{dir} #{BUCKET}" 
+    cmd "sudo ruby ./installer/utils/package_upload/s3_upload.rb #{PKG_DIR}/#{dir} #{BUCKET}"
   end #do
   cmd "sudo ruby ./installer/utils/package_upload/s3_upload.rb #{PKG_DIR}/SHA1 #{BUCKET}"
 end #build:repos

data/js-adapters/node.rb

@@ -24,13 +24,13 @@ module Rhoconnect
           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}", 
-            "REDIS_URL" => Rhoconnect.redis_url 
+          sub_env = {
+            "NODE_PATH" => "#{node_modules}#{File::PATH_SEPARATOR}#{pwd}#{File::PATH_SEPARATOR}#{dir}",
+            "REDIS_URL" => Rhoconnect.redis_url
           }
           file = File.join(dir,"server.js")
           args = [
-            sub_env, "node", file, Rhoconnect::NodeChannel::PUBSUB_IDENTIFIER, 
+            sub_env, "node", file, Rhoconnect::NodeChannel::PUBSUB_IDENTIFIER,
             Rhoconnect.environment.to_s, Rhoconnect.base_directory
           ]
           @pipe = IO.popen(args, "w")

data/js-adapters/node_channel.rb

@@ -10,18 +10,13 @@ module Rhoconnect
     end
 
     RESULT_HASH          = {}
-    TIMEOUT              = 30 # seconds
     PUBSUB_IDENTIFIER    = "#{$$}-#{SecureRandom.hex}"
     PUB_CHANNEL          = "#{PUBSUB_IDENTIFIER}-RedisSUB" # pub channel must link to redis sub channel
     SUB_CHANNEL          = "#{PUBSUB_IDENTIFIER}-RedisPUB" # sub channel must link to redis pub channel
     @message_thread,@redis_subscriber,@redis_publisher = nil
 
     class << self
-      attr_accessor :thrd, :register_semaphore, :register_condition
-
-      def get_timeout
-        TIMEOUT
-      end
+      attr_accessor :thrd, :register_semaphore, :register_condition, :timeout
 
       def redis_subscriber
         url = Rhoconnect.redis.is_a?(Array) ? Rhoconnect.redis[0] : Rhoconnect.redis
@@ -41,7 +36,7 @@ module Rhoconnect
         NodeChannel.redis_publisher.publish(PUB_CHANNEL,{:route => 'deregister'}.to_json)
       end
 
-      def bootstrap
+      def bootstrap(timeout)
         @register_semaphore ||= Mutex.new
         @register_condition ||= ConditionVariable.new
         # Run in the main thread, we setup node thread and wait for it to
@@ -54,6 +49,7 @@ module Rhoconnect
           @message_thread = Thread.new{check_channel}
           @register_condition.wait(@register_semaphore)
         end
+        @timeout = timeout
       end
 
       def publish_channel_and_wait(msg,curr_model)
@@ -97,7 +93,7 @@ module Rhoconnect
 
       def wait_for_result(key,curr_model)
         begin
-          Timeout::timeout(TIMEOUT) do
+          Timeout::timeout(@timeout) do
             while(RESULT_HASH[key][:status] == 'waiting') do
               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

data/lib/rhoconnect/db_adapter.rb

@@ -1,11 +1,11 @@
 require 'singleton'
 
-class DBAdapter 
+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)  
+  # 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
       require 'dbi'
@@ -18,25 +18,25 @@ class DBAdapter
             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
+        # 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.9
+          self.do_transaction(&block)
+          self['AutoCommit'] = true
+        end
+      end
+    else # MRI Ruby
       require 'sqlite3'
       db = SQLite3::Database.new(dbfile)
     end
 
-    db 
-  end   
+    db
+  end
 end

data/lib/rhoconnect/handler/changes/engine.rb

@@ -236,7 +236,7 @@ module Rhoconnect
             # call logoff
             auth_method('logoff')
           end
-
+          
           { "delete_page" => deletes,
             "#{operation}_links" => links,
             "#{operation}_errors" => errors }.each do |doctype,client_docs|

data/lib/rhoconnect/jobs/bulk_data_job.rb

@@ -1,10 +1,10 @@
-require 'zip/zip'
+require 'zip'
 require 'zlib'
 
 module Rhoconnect
   module BulkDataJob
     @queue = :bulk_data
-    
+
     def self.perform(params)
       do_bulk_job(params) do |bulk_data|
         timer = start_timer('starting bulk data process')
@@ -50,7 +50,7 @@ module Rhoconnect
       data = source.get_data(:md) if is_selected
       counter = {}
       db.transaction do |database|
-        database.prepare("insert into object_values 
+        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|
@@ -62,20 +62,20 @@ module Rhoconnect
       end
       counter
     end
-    
+
     # Loads data into fixed schema table based on source settings
     def self.import_data_to_fixed_schema(db,source,is_selected=true)
       data = {}
       data = source.get_data(:md) if is_selected
-      counter = {}
+      # 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" 
+          create_table << "\"#{key}\" varchar default NULL"
           columns << key
           qm << '?'
         end
@@ -86,11 +86,11 @@ module Rhoconnect
             args = [obj]
             columns.each { |col| args << row[col] }
             # The * is used to expand an array into individual arguments for 'execute' method.
-            # JRuby (1.6.0) won't work without asterisk, but other rubies doing well! 
-            stmt.execute(*args) 
+            # JRuby (1.6.0) won't work without asterisk, but other rubies doing well!
+            stmt.execute(*args)
           end
         end
-        
+
         # Create indexes for specified columns in settings 'index'
         schema['index'].each do |key,value|
           val2 = ""
@@ -98,10 +98,10 @@ module Rhoconnect
             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 = ""
@@ -109,14 +109,14 @@ module Rhoconnect
             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|
@@ -124,15 +124,15 @@ module Rhoconnect
       end
       str[0..-2]
     end
-    
+
     # #2354: Bulk sync not updating sources table
     # last_inserted_size +
     # last_deleted_size
     # backend_refresh_time +
-    def self.populate_sources_table(db,sources_refs) 
+    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,last_inserted_size,backend_refresh_time) 
+          (source_id,name,sync_priority,partition,sync_type,source_attribs,metadata,schema,blob_attribs,associations,last_inserted_size,backend_refresh_time)
           values (?,?,?,?,?,?,?,?,?,?,?,?)") do |stmt|
           sources_refs.each do |source_name,ref|
             s = ref[:source]
@@ -144,7 +144,7 @@ module Rhoconnect
         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)
@@ -152,9 +152,9 @@ module Rhoconnect
       # TODO: remove old bulk files!
       # FileUtils.rm Dir.glob(File.join(Rhoconnect.data_directory, "#{bulk_data.name}*"))
 
-      db = DBAdapter.instance.get_connection(bulk_data.dbfile)    
+      db = DBAdapter.instance.get_connection(bulk_data.dbfile)
       db.execute_batch(File.open(schema,'r').read)
-      
+
       src_counter = 1
       selected_sources = {}
       bulk_data.sources[0, -1].each do |source|
@@ -173,33 +173,33 @@ module Rhoconnect
         else
           source_attrib_refs = import_data_to_object_values(db,source,is_selected_source)
         end
-        sources_refs[source_name] = 
+        sources_refs[source_name] =
           {:source => source, :refs => source_attrib_refs, :skip_source => !is_selected_source}
         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.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|
+      Zip::File.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|
@@ -209,6 +209,6 @@ module Rhoconnect
       end
       data.close
     end
-    
+
   end
 end

data/lib/rhoconnect/license.rb

@@ -4,7 +4,7 @@ require 'pathname'
 module Rhoconnect
   class LicenseException < RuntimeError; end
   class LicenseSeatsExceededException < LicenseException; end
-  
+
   class License
     attr_reader :rhoconnect_version, :licensee, :seats, :issued
     attr_accessor :license
@@ -20,9 +20,9 @@ module Rhoconnect
         elsif ENV['RHOSYNC_LICENSE']
           @license = ENV['RHOSYNC_LICENSE']
         else
-          app_config = Rhoconnect.get_config(Rhoconnect.base_directory)
+          # app_config = Rhoconnect.get_config(Rhoconnect.base_directory)
           settings = Rhoconnect.get_config(Rhoconnect.base_directory)[Rhoconnect.environment]
-          licensefile = settings[:licensefile] 
+          licensefile = settings[:licensefile]
           if licensefile
             path_to_license = (Pathname.new(licensefile).absolute?) ? licensefile : File.join(Rhoconnect.base_directory, licensefile)
           else
@@ -37,7 +37,7 @@ module Rhoconnect
         raise LicenseException.new("Error verifying license.")
       end
     end
-    
+
     def check_and_use_seat
       incr = false
       Store.lock(CLIENT_DOCKEY) do
@@ -53,7 +53,7 @@ module Rhoconnect
         log msg; raise LicenseSeatsExceededException.new(msg)
       end
     end
-    
+
     def free_seat
       Store.lock(CLIENT_DOCKEY) do
         current = Store.get_value(CLIENT_DOCKEY)
@@ -63,14 +63,14 @@ module Rhoconnect
         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