rhoconnect 3.0.0.beta1

data/spec/testdata/compressed/compress-data.txt

@@ -0,0 +1 @@
+some compressed text

data/spec/testdata/upload1.txt

@@ -0,0 +1 @@
+hello

data/spec/testdata/upload2.txt

@@ -0,0 +1 @@
+world

data/spec/user_spec.rb

@@ -0,0 +1,139 @@
+require File.join(File.dirname(__FILE__),'spec_helper')
+require File.join(File.dirname(__FILE__), 'support', 'shared_examples')
+
+STATS_RECORD_RESOLUTION = 2 unless defined? STATS_RECORD_RESOLUTION
+STATS_RECORD_SIZE = 8 unless defined? STATS_RECORD_SIZE
+
+describe "User" do
+  it_behaves_like "SharedRhoconnectHelper", :rhoconnect_data => true do
+    it "should not allow user created with reserved login" do
+      Store.get_value('user:count').should == "1"
+      lambda {
+        User.create({:login => '__shared__'})
+        }.should raise_error(ArgumentError, 'Reserved user id __shared__')
+      Store.get_value('user:count').should == "1"
+    end
+      
+    it "should create user with fields" do
+      @u.id.should == @u_fields[:login]
+      @u1 = User.load(@u_fields[:login])
+      @u1.id.should == @u.id
+      @u1.login.should == @u_fields[:login]
+      @u1.email.should == @u_fields[:email]
+      Store.get_value('user:count').should == "1"
+    end
+
+    it "should delete seats for user's clients" do
+      Client.create(@c_fields,{:source_name => @s_fields[:name]})
+      c_size = @u.clients.members.size
+      current = Store.get_value(License::CLIENT_DOCKEY).to_i
+      @u.delete
+      Store.get_value(License::CLIENT_DOCKEY).to_i.should == current - c_size
+    end
+
+    it "should create token for user" do
+      token = @u.create_token
+      token.length.should == 32
+      ApiToken.load(token).user_id.should == @u.id
+    end
+
+    it "should get token for user" do
+      token = @u.create_token
+      @u.token.value.length.should == 32
+      @u.token.value.should == token
+    end
+
+    it "should use token provisioned in settings if one" do
+      token = @u.create_token
+      token.should == Rhoconnect.api_token
+      ApiToken.is_exist?(token).should == true
+    end
+    
+    it "should delete token if one exists" do
+      token = @u.create_token
+      token.should == Rhoconnect.api_token
+      ApiToken.is_exist?(token).should == true
+      token = @u.create_token
+      ApiToken.is_exist?(token).should == true
+      @u.delete
+    end
+
+    it "should assign token to existing user" do
+      token = @u.create_token
+      @u.token = 'foo'
+      @u.token.value.should == 'foo'
+      ApiToken.is_exist?('foo').should == true
+      ApiToken.is_exist?(token).should == false
+    end
+
+    it "should authenticate with proper credentials" do
+      @u1 = User.authenticate(@u_fields[:login],'testpass')
+      @u1.should_not be_nil
+      @u1.login.should == @u_fields[:login]
+      @u1.email.should == @u_fields[:email]
+    end
+
+    it "should fail to authenticate with invalid credentials" do
+      User.authenticate(@u_fields[:login],'wrongpass').should be_nil
+    end
+
+    it "should fail to authenticate with nil user" do
+      User.authenticate('niluser','doesnotmatter').should be_nil
+    end
+
+    it "should delete user and user clients" do
+      @c.put_data(:cd,@data)
+      cid = @c.id    
+      @u.delete
+      Store.get_value('user:count').should == "0"
+      User.is_exist?(@u_fields[:login]).should == false
+      Client.is_exist?(cid).should == false
+      @c.get_data(:cd).should == {}
+    end
+
+    it "should delete token for user" do
+      token = @u.create_token
+      @u.delete
+      ApiToken.is_exist?(token).should == false
+    end
+
+    describe "User Stats" do
+
+      before(:all) do
+        Store.stub!(:lock).and_yield
+      end
+
+      before(:each) do
+        Rhoconnect::Stats::Record.reset('users')
+      end
+
+      after(:each) do
+        Rhoconnect::Stats::Record.reset('users')
+      end
+
+      after(:all) do
+        Store.flash_data('stat:users*')
+      end
+
+      it "should increment user stats on create" do
+        Time.stub!(:now).and_return(10)
+        Rhoconnect.stats = true
+        User.create({:login => 'testuser2'})
+        Rhoconnect::Stats::Record.range('users',0,-1).should == ["2:10"]
+        Store.get_value('user:count').should == "2"
+        Rhoconnect.stats = false
+      end
+
+      it "should decrement user stats on delete" do
+        Time.stub!(:now).and_return(10)
+        Rhoconnect.stats = true
+        u = User.create({:login => 'testuser1'})
+        Rhoconnect::Stats::Record.range('users',0,-1).should == ["2:10"]
+        u.delete
+        Rhoconnect::Stats::Record.range('users',0,-1).should == ["1:10"]
+        Store.get_value('user:count').should == "1"
+        Rhoconnect.stats = false
+      end
+    end
+  end
+end

data/tasks/redis.rake

@@ -0,0 +1,206 @@
+# Inspired by rabbitmq.rake the Redbox project at http://github.com/rick/redbox/tree/master
+require 'fileutils'
+require 'open-uri'
+
+def windows?
+	RUBY_PLATFORM =~ /(win|w)32$/
+end
+
+if windows?
+	$redis_ver = "redis-2.2.12"
+	$redis_zip = "C:/#{$redis_ver}.zip"
+	$redis_dest = "C:/"
+end
+
+def redis_home
+  ENV['REDIS_HOME'] || File.join($redis_dest,$redis_ver)
+end
+
+def mk_bin_dir(bin_dir)
+  begin
+    mkdir_p bin_dir unless File.exists?(bin_dir)
+  rescue
+    puts "Can't create #{bin_dir}, maybe you need to run command as root?"
+    exit 1
+  end
+end
+	
+class RedisRunner
+  
+  def self.prefix
+    "/usr/local/"
+  end
+
+  def self.redisdir
+    "/tmp/redis/"
+  end
+
+  def self.redisconfdir
+    server_dir = File.dirname(`which redis-server`)
+    conf_file = "#{RedisRunner.prefix}etc/redis.conf"
+    unless File.exists? conf_file
+      conf_file = "#{server_dir}/redis.conf"
+    end
+    conf_file
+  end
+
+  def self.dtach_socket
+    '/tmp/redis.dtach'
+  end
+
+  # Just check for existance of dtach socket
+  def self.running?
+    File.exists? dtach_socket
+  end
+
+  def self.start
+  	if windows?
+  		puts "Starting redis in a new window..."
+  		sh "start #{File.join(redis_home,'redis-server')} #{File.join(redis_home,'redis.conf')}" rescue
+  			"redis-server not installed on your path, please run 'rake redis:install' first."
+    elsif defined?(JRUBY_VERSION)
+      puts "Starting redis ..."
+      sh "redis-server #{redisconfdir}"
+    else
+      puts 'Detach with Ctrl+\  Re-attach with rake redis:attach'
+      sleep 1
+      command = "dtach -A #{dtach_socket} redis-server #{redisconfdir}"
+      sh command
+    end
+  end
+
+  def self.attach
+    exec "dtach -a #{dtach_socket}"
+  end
+
+  def self.stop
+    Redis.new.shutdown rescue nil
+  end
+
+end
+
+namespace :redis do
+
+  desc 'About redis'
+  task :about do
+    puts "\nSee http://redis.io/ for information about redis.\n\n"
+  end
+
+  desc 'Start redis'
+  task :start do
+    RedisRunner.start
+  end
+
+  desc 'Stop redis'
+  task :stop do
+    RedisRunner.stop
+  end
+
+  desc 'Restart redis'
+  task :restart do
+    RedisRunner.stop
+    RedisRunner.start
+  end
+
+  desc 'Attach to redis dtach socket'
+  task :attach do
+    RedisRunner.attach
+  end
+
+  desc 'Install the latest verison of Redis from Github (requires git, duh)'
+  task :install => [:about, :download, :make] do
+  	unless windows?
+	    ENV['PREFIX'] and bin_dir = "#{ENV['PREFIX']}/bin" or bin_dir = "#{RedisRunner.prefix}bin"
+	    
+	    mk_bin_dir(bin_dir)
+	    
+	    %w(redis-benchmark redis-cli redis-server).each do |bin|
+	      sh "cp /tmp/redis/src/#{bin} #{bin_dir}"
+	    end
+	
+	    puts "Installed redis-benchmark, redis-cli and redis-server to #{bin_dir}"
+	
+	    ENV['PREFIX'] and conf_dir = "#{ENV['PREFIX']}/etc" or conf_dir = "#{RedisRunner.prefix}etc"
+	    unless File.exists?("#{conf_dir}/redis.conf")
+	      sh "mkdir #{conf_dir}" unless File.exists?("#{conf_dir}")
+	      sh "cp /tmp/redis/redis.conf #{conf_dir}/redis.conf"
+	      puts "Installed redis.conf to #{conf_dir} \n You should look at this file!"
+	    end
+    end
+	end
+
+  task :make do
+  	unless windows?
+      sh "cd #{RedisRunner.redisdir} && make clean"
+      sh "cd #{RedisRunner.redisdir} && make"
+    end
+  end
+
+  desc "Download package"
+  task :download do
+  	if windows?
+      require 'net/http'
+      require 'zip/zip'
+      puts "Installing redis to #{redis_home}."
+
+	    Net::HTTP.start("cloud.github.com") do |http|
+	      resp = http.get("/downloads/dmajkic/redis/#{$redis_ver}-win32-win64.zip")
+	      open($redis_zip, "wb") do |file|
+	        file.write(resp.body)
+	      end
+	    end
+
+	    Zip::ZipFile.open($redis_zip) do |zip_file|
+	    	zip_file.each do |f|
+	    		f_path = File.join(redis_home, f.name)
+          FileUtils.mkdir_p(File.dirname(f_path))
+          zip_file.extract(f, f_path) { true }
+    		end
+    	end
+
+    	FileUtils.mv Dir.glob(File.join(redis_home,'32bit','*')), redis_home
+    	FileUtils.rm_rf File.join(redis_home, '64bit')
+    	FileUtils.rm_f $redis_zip
+    else
+      sh 'rm -rf /tmp/redis/' if File.exists?("#{RedisRunner.redisdir}")
+      sh 'git clone git://github.com/antirez/redis.git /tmp/redis -n'
+      sh "cd #{RedisRunner.redisdir} && git reset --hard && git checkout 2.2.12"
+    end
+  end
+
+end
+
+namespace :dtach do
+
+  desc 'About dtach'
+  task :about do
+    puts "\nSee http://dtach.sourceforge.net/ for information about dtach.\n\n"
+  end
+
+  desc 'Install dtach 0.8 from source'
+  task :install => [:about] do
+    unless windows?
+      Dir.chdir('/tmp/')
+      unless File.exists?('/tmp/dtach-0.8.tar.gz')
+        require 'net/http'
+
+        url = 'http://downloads.sourceforge.net/project/dtach/dtach/0.8/dtach-0.8.tar.gz'
+        open('/tmp/dtach-0.8.tar.gz', 'wb') do |file| file.write(open(url).read) end
+      end
+
+      unless File.directory?('/tmp/dtach-0.8')
+        system('tar xzf dtach-0.8.tar.gz')
+      end
+
+      ENV['PREFIX'] and bin_dir = "#{ENV['PREFIX']}/bin" or bin_dir = "#{RedisRunner.prefix}bin"
+      
+      mk_bin_dir(bin_dir)
+	    
+      Dir.chdir('/tmp/dtach-0.8/')
+      sh 'cd /tmp/dtach-0.8/ && ./configure && make'
+      sh "cp /tmp/dtach-0.8/dtach #{bin_dir}"
+
+      puts "Dtach successfully installed to #{bin_dir}"
+    end
+  end
+end