filecluster 0.4.5 → 0.4.6

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 65712f8a51ce15000b05922338f8621f5cd4caec
+  data.tar.gz: 4802352703fc5964a40517f8c7d95eb2a87c0892
+SHA512:
+  metadata.gz: 57a574d9d3ab392e09861425b267fda89c7485e9b107253db65edf77d58809067eb60e1d1b1072cdfd7cd1befc2578ab83eb65063cee9121553a129c78cb9340
+  data.tar.gz: 94dc33d6b766cfd6958ae38f0e1760ef5557dd81fd63ed314687ce08e3c925cbe4f7aea0d6483a4750b3a2cb4c89a5413c01482ea00878e8db9b7b9ecbf2b7d3

data/README.md

@@ -59,6 +59,7 @@ Can be used the following variables:
 |daemon_tasks_copy_threads_limit|10|copy tasks threads count limit for one storage|
 |daemon_tasks_delete_threads_limit|10|delete tasks threads count limit for one storage|
 |daemon_copy_tasks_per_host_limit|10|copy tasks count limit for one host|
+|daemon_copy_speed_per_host_limit|0|copy tasks speed limit for hosts, change via fc-manage copy_speed|
 |daemon_global_tasks_group_limit|1000|select limit for create copy tasks|
 |daemon_global_error_items_ttl|86400|ttl for items with error status before delete|
 |daemon_global_error_items_storages_ttl|86400|ttl for items_storages with error status before delete|

data/bin/fc-daemon

@@ -17,6 +17,7 @@ $tasks_copy_threads   = {}          # copy threads by storage name
 $tasks_delete_threads = {}          # delete threads by storage name
 $check_threads        = {}          # check threads by storage name
 $copy_count           = 0           # copy tasks count for current host
+$copy_speed           = 0           # copy tasks speed sum for current host
 $exit_signal          = false 
 $global_daemon_thread = nil
 $update_tasks_thread  = nil

data/bin/fc-manage

@@ -64,6 +64,14 @@ Command:
    list                show all FC::Var-s
    show <variable>     show current value for variable   
    change <variable>   change variable       
+}],
+  'copy_speed' => [
+    'show and change copy speed limit for FC hosts', 
+    %q{Usage: fc-manage [options] copy_speed <command>
+Command:
+   list                show all limits
+   change <host>       change current copy speed limit for host   
+   add                 add copy speed limit for host
 }],
   'item' => [
     'show and manage items', 
@@ -79,8 +87,8 @@ desc = %q{Get info and manage for storages, policies and items.
 Usage: fc-manage [options] <command> [<args>]
 Commands:
 }
-commands_help.each{|key, val| desc << "   #{key}#{" "*(10-key.size)}#{val[0]}\n"}
-desc << "   help      show help for commands ('fc-manage help <command>')\n"
+commands_help.each{|key, val| desc << "   #{key}#{" "*(11-key.size)}#{val[0]}\n"}
+desc << "   help       show help for commands ('fc-manage help <command>')\n"
 $options = option_parser_init(descriptions, desc)
 FC::Storage.instance_variable_set(:@uname, $options[:curr_host]) if $options[:curr_host] && $options[:curr_host] != FC::Storage.curr_host
 trap("INT", proc {exit})

data/bin/fc-setup-db

@@ -8,22 +8,35 @@ require 'utils'
 require 'readline'
 
 descriptions = {
-  :host =>       {:short => 'h', :full => 'host',     :default => 'localhost', :text => 'mysql host name, default "localhost"', :save => true},
-  :database =>   {:short => 'd', :full => 'db',       :default => 'fc',        :text => 'mysql database, default "fc"', :save => true},
-  :username =>   {:short => 'u', :full => 'user',     :default => 'root',      :text => 'mysql user, default "root"', :save => true},
-  :password =>   {:short => 'p', :full => 'password', :default => '',          :text => 'mysql password, default ""', :save => true},
-  :port =>       {:short => 'P', :full => 'port',     :default => '3306',      :text => 'mysql port, default "3306"', :save => true},
-  :prefix =>     {:short => 't', :full => 'prefix',   :default => '',          :text => 'tables prefix, default ""', :save => true},
-  :init_tables =>{:short => 'i', :full => 'init',     :default => false,       :text => 'init tables, default no', :no_val => true},
-  :force =>      {:short => 'f', :full => 'force',    :default => false,       :text => 'do not ask questions', :no_val => true}
+  :host =>       {:short => 'h', :full => 'host',      :default => 'localhost', :text => 'mysql host name, default "localhost"', :save => true},
+  :database =>   {:short => 'd', :full => 'db',        :default => 'fc',        :text => 'mysql database, default "fc"', :save => true},
+  :username =>   {:short => 'u', :full => 'user',      :default => 'root',      :text => 'mysql user, default "root"', :save => true},
+  :password =>   {:short => 'p', :full => 'password',  :default => '',          :text => 'mysql password, default ""', :save => true},
+  :port =>       {:short => 'P', :full => 'port',      :default => '3306',      :text => 'mysql port, default "3306"', :save => true},
+  :prefix =>     {:short => 't', :full => 'prefix',    :default => '',          :text => 'tables prefix, default ""', :save => true},
+  :init_tables =>{:short => 'i', :full => 'init',      :default => false,       :text => 'init tables, default no', :no_val => true},
+  :force =>      {:short => 'f', :full => 'force',     :default => false,       :text => 'do not ask questions', :no_val => true},
+  :migrations => {:short => 'm', :full => 'migrations',:default => false,       :text => 'Make not ask questions', :no_val => true}
 }
 desc = %q{Setup FileCluster database connection options.
-Create tables if nessary.
+Create tables on --init.
+Make database migrations on --migrations.
+If no host, database, username, password, port, prefix try to use current db.yml.
 Usage: fc-init-db [options]}
 options = option_parser_init(descriptions, desc)
-options.delete('optparse')
 trap("INT", proc {exit})
 
+if !options[:__keys][:host] && !options[:__keys][:database] && !options[:__keys][:username] && !options[:__keys][:password] && !options[:__keys][:port] && !options[:__keys][:prefix]
+  default_db_config = File.expand_path(File.dirname(__FILE__))+'/db.yml'
+  if File.exists?(default_db_config)
+    db_options = Psych.load(File.read(default_db_config))
+    options.merge!(db_options)
+    
+  end
+end
+options.delete('optparse')
+options.delete(:__keys)
+
 puts options.inspect.gsub(/[\{\}\:]/, "").gsub(", ", "\n").gsub(/(.{7,})=>/, "\\1:\t").gsub("=>", ":\t\t")
 
 s = options[:force] ? 'y' : Readline.readline("Continue? (y/n) ", false).strip.downcase
@@ -37,12 +50,19 @@ if s == "y" || s == "yes"
     FC::DB.init_db
     puts "ok"
   end
-  print "Save to config..   "
-  options.select!{|key, val| descriptions[key][:save]}
-  File.open(File.expand_path(File.dirname(__FILE__))+'/db.yml', 'w') do |f|
-    f.write(options.to_yaml)
+  unless default_db_config
+    print "Save to config..   "
+    options.select!{|key, val| descriptions[key][:save]}
+    File.open(File.expand_path(File.dirname(__FILE__))+'/db.yml', 'w') do |f|
+      f.write(options.to_yaml)
+    end
+    puts "ok"
+  end
+  if options[:migrations]
+    print "Make migrations..   "
+    FC::DB.migrations
+    puts "ok"
   end
-  puts "ok"
 else
   puts "Canceled."
 end

data/lib/daemon/copy_task_thread.rb

@@ -4,7 +4,7 @@ class CopyTaskThread < BaseThread
     Thread.current[:tasks_processed] = 0 unless Thread.current[:tasks_processed]
     while task = $tasks_copy[storage_name].shift do
       $curr_tasks << task
-      $log.debug("CopyTaskThread(#{storage_name}): run task for item_storage ##{task.id}, copy_count=#{$copy_count}")
+      $log.debug("CopyTaskThread(#{storage_name}): run task for item_storage ##{task.id}, copy_count=#{$copy_count}, copy_speed=#{$copy_speed}")
       make_copy(task)
       $curr_tasks.delete(task)
       $log.debug("CopyTaskThread(#{storage_name}): finish task for item_storage ##{task.id}")
@@ -15,7 +15,18 @@ class CopyTaskThread < BaseThread
   
   def make_copy(task)
     sleep 0.1 while $copy_count > FC::Var.get('daemon_copy_tasks_per_host_limit', 10).to_i
+    limit = FC::Var.get_current_speed_limit
+    speed_limit = nil
+    if limit
+      if $copy_count == 0
+        speed_limit = (limit - $copy_speed) / 0.75
+      else
+        sleep 0.1 while (speed_limit = (limit - $copy_speed) / ($copy_count + 0.4)) < limit*0.1
+      end
+    end
     $copy_count += 1
+    $copy_speed += speed_limit if speed_limit
+    
     storage = $storages.detect{|s| s.name == task.storage_name}
     begin
       item = FC::Item.find(task.item_id)
@@ -35,11 +46,12 @@ class CopyTaskThread < BaseThread
     end
     src_storage = $all_storages.detect{|s| s.name == src_item_storage.storage_name}
     $log.debug("Copy from #{src_storage.name} to #{storage.name} #{storage.path}#{item.name}")
-    item.copy_item_storage(src_storage, storage, task)
+    item.copy_item_storage(src_storage, storage, task, speed_limit)
   rescue Exception => e
     error "Copy item_storage error: #{e.message}; #{e.backtrace.join(', ')}", :item_id => task.item_id, :item_storage_id => task.id
     $curr_tasks.delete(task)
   ensure 
     $copy_count -= 1 if $copy_count > 0
+    $copy_speed -= speed_limit if speed_limit
   end
 end

data/lib/fc/copy_rule.rb

@@ -30,14 +30,10 @@ module FC
     
     # get available storage for copy
     def self.get_proper_storage_for_copy(options)
-      exclude = options[:exclude] || []
       rules = check_all(options[:item_id].to_i, options[:size].to_i, options[:item_copies].to_i, options[:name].to_s, options[:tag].to_s, options[:dir] ? true : false, options[:src_storage])
       result = nil
-      rules.each do |rule|
-        result = rule.get_copy_storages.select do |storage|
-          !exclude.include?(storage.name) && storage.up? && storage.size + options[:size].to_i < storage.size_limit
-        end.first
-        break if result
+      rules.detect do |rule|
+        result = FC::Storage.select_proper_storage_for_create(rule.get_copy_storages, options[:size].to_i, options[:exclude] || [])
       end
       result
     end

data/lib/fc/db.rb

@@ -6,13 +6,27 @@ module FC
     
     def self.connect_by_config(options)
       @options = options.clone
-      @options[:port] = options[:port].to_i if options[:port]
-      @prefix = options[:prefix].to_s if options[:prefix]
-      @connects = {}
+      @options[:port] = @options[:port].to_i if @options[:port]
+      @prefix = @options[:prefix].to_s if @options[:prefix]
+      @connects = {} unless @connects
       @connects[Thread.current.object_id] = Mysql2::Client.new(@options)
     end
     
-    def self.connect
+    def self.connect(options = {})
+      if !@options
+        if defined?(ActiveRecord::Base) && ActiveRecord::Base.connection
+          connection = ActiveRecord::Base.connection.instance_variable_get(:@connection)
+          @options = connection.query_options.clone
+          @options.merge!(options)
+          @prefix = @options[:prefix].to_s if @options[:prefix]
+          @connects = {} unless @connects
+          @connects[Thread.current.object_id] = connection
+        else
+          self.connect_by_config(options)
+        end
+      else
+        @options.merge!(options)
+      end
       if @options[:multi_threads]
         @connects[Thread.current.object_id] ||= Mysql2::Client.new(@options)
       else
@@ -20,9 +34,18 @@ module FC
       end
     end
     
+    def self.connect!(options = {})
+      self.connect(options)
+    end
+    
+    # deprecated!
     def self.connect=(connect, options = {})
       self.connect_by_config connect.query_options.merge(options).merge(:as => :hash)
     end
+    class << self
+      extend Gem::Deprecate
+      deprecate :connect=, :connect!, 2016, 01
+    end
     
     def self.close
       if @options[:multi_threads]
@@ -37,7 +60,9 @@ module FC
     
     # connect.query with deadlock solution
     def self.query(sql)
-      FC::DB.connect.query(sql)
+      r = FC::DB.connect.query(sql)
+      r = r.each(:as => :hash){} if r
+      r
     rescue Mysql2::Error => e
       if e.message.match('Deadlock found when trying to get lock')
         puts "Deadlock"
@@ -51,14 +76,14 @@ module FC
       else
         raise e
       end
-    end
+    end    
     
     def self.server_time
       FC::DB.query("SELECT UNIX_TIMESTAMP() as curr_time").first['curr_time'].to_i
     end
     
-    def self.init_db
-      FC::DB.connect.query(%{
+    def self.init_db(silent = false)
+      FC::DB.query(%{
         CREATE TABLE #{@prefix}items (
           id int NOT NULL AUTO_INCREMENT,
           name varchar(1024) NOT NULL DEFAULT '',
@@ -78,10 +103,10 @@ module FC
       proc_time = %{
         SET NEW.time = UNIX_TIMESTAMP();
       }
-      FC::DB.connect.query("CREATE TRIGGER fc_items_before_insert BEFORE INSERT on #{@prefix}items FOR EACH ROW BEGIN #{proc_time} END")
-      FC::DB.connect.query("CREATE TRIGGER fc_items_before_update BEFORE UPDATE on #{@prefix}items FOR EACH ROW BEGIN #{proc_time} END")
+      FC::DB.query("CREATE TRIGGER fc_items_before_insert BEFORE INSERT on #{@prefix}items FOR EACH ROW BEGIN #{proc_time} END")
+      FC::DB.query("CREATE TRIGGER fc_items_before_update BEFORE UPDATE on #{@prefix}items FOR EACH ROW BEGIN #{proc_time} END")
       
-      FC::DB.connect.query(%{
+      FC::DB.query(%{
         CREATE TABLE #{@prefix}storages (
           id int NOT NULL AUTO_INCREMENT,
           name varchar(255) NOT NULL DEFAULT '',
@@ -108,10 +133,10 @@ module FC
           #{proc}
         END IF;
       }
-      FC::DB.connect.query("CREATE TRIGGER fc_storages_after_delete AFTER DELETE on #{@prefix}storages FOR EACH ROW BEGIN #{proc} END")
-      FC::DB.connect.query("CREATE TRIGGER fc_storages_after_update AFTER UPDATE on #{@prefix}storages FOR EACH ROW BEGIN #{proc_update} END")
+      FC::DB.query("CREATE TRIGGER fc_storages_after_delete AFTER DELETE on #{@prefix}storages FOR EACH ROW BEGIN #{proc} END")
+      FC::DB.query("CREATE TRIGGER fc_storages_after_update AFTER UPDATE on #{@prefix}storages FOR EACH ROW BEGIN #{proc_update} END")
       
-      FC::DB.connect.query(%{
+      FC::DB.query(%{
         CREATE TABLE #{@prefix}policies (
           id int NOT NULL AUTO_INCREMENT,
           name varchar(255) NOT NULL DEFAULT '',
@@ -125,10 +150,10 @@ module FC
         SELECT GROUP_CONCAT(name ORDER BY FIND_IN_SET(name, NEW.create_storages)) INTO @create_storages_list FROM #{@prefix}storages WHERE FIND_IN_SET(name, NEW.create_storages);
         SET NEW.create_storages = @create_storages_list;
       }
-      FC::DB.connect.query("CREATE TRIGGER fc_policies_before_insert BEFORE INSERT on #{@prefix}policies FOR EACH ROW BEGIN #{proc} END")
-      FC::DB.connect.query("CREATE TRIGGER fc_policies_before_update BEFORE UPDATE on #{@prefix}policies FOR EACH ROW BEGIN #{proc} END")
+      FC::DB.query("CREATE TRIGGER fc_policies_before_insert BEFORE INSERT on #{@prefix}policies FOR EACH ROW BEGIN #{proc} END")
+      FC::DB.query("CREATE TRIGGER fc_policies_before_update BEFORE UPDATE on #{@prefix}policies FOR EACH ROW BEGIN #{proc} END")
       
-      FC::DB.connect.query(%{
+      FC::DB.query(%{
         CREATE TABLE #{@prefix}items_storages (
           id int NOT NULL AUTO_INCREMENT,
           item_id int DEFAULT NULL,
@@ -165,13 +190,13 @@ module FC
         #{proc.gsub('NEW', 'OLD')}
         UPDATE #{@prefix}storages SET size=size-@item_size WHERE name = OLD.storage_name;
       }
-      FC::DB.connect.query("CREATE TRIGGER fc_items_storages_before_insert BEFORE INSERT on #{@prefix}items_storages FOR EACH ROW BEGIN #{proc_time} END")
-      FC::DB.connect.query("CREATE TRIGGER fc_items_storages_before_update BEFORE UPDATE on #{@prefix}items_storages FOR EACH ROW BEGIN #{proc_time} END")
-      FC::DB.connect.query("CREATE TRIGGER fc_items_storages_after_update AFTER UPDATE on #{@prefix}items_storages FOR EACH ROW BEGIN #{proc} END")
-      FC::DB.connect.query("CREATE TRIGGER fc_items_storages_after_insert AFTER INSERT on #{@prefix}items_storages FOR EACH ROW BEGIN #{proc_add} END")
-      FC::DB.connect.query("CREATE TRIGGER fc_items_storages_after_delete AFTER DELETE on #{@prefix}items_storages FOR EACH ROW BEGIN #{proc_del} END")
+      FC::DB.query("CREATE TRIGGER fc_items_storages_before_insert BEFORE INSERT on #{@prefix}items_storages FOR EACH ROW BEGIN #{proc_time} END")
+      FC::DB.query("CREATE TRIGGER fc_items_storages_before_update BEFORE UPDATE on #{@prefix}items_storages FOR EACH ROW BEGIN #{proc_time} END")
+      FC::DB.query("CREATE TRIGGER fc_items_storages_after_update AFTER UPDATE on #{@prefix}items_storages FOR EACH ROW BEGIN #{proc} END")
+      FC::DB.query("CREATE TRIGGER fc_items_storages_after_insert AFTER INSERT on #{@prefix}items_storages FOR EACH ROW BEGIN #{proc_add} END")
+      FC::DB.query("CREATE TRIGGER fc_items_storages_after_delete AFTER DELETE on #{@prefix}items_storages FOR EACH ROW BEGIN #{proc_del} END")
       
-      FC::DB.connect.query(%{
+      FC::DB.query(%{
         CREATE TABLE #{@prefix}errors (
           id int NOT NULL AUTO_INCREMENT,
           item_id int DEFAULT NULL,
@@ -182,9 +207,9 @@ module FC
           PRIMARY KEY (id), KEY (item_id), KEY (item_storage_id), KEY (host), KEY (time)
         ) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci
       })
-      FC::DB.connect.query("CREATE TRIGGER fc_errors_before_insert BEFORE INSERT on #{@prefix}errors FOR EACH ROW BEGIN #{proc_time} END")
+      FC::DB.query("CREATE TRIGGER fc_errors_before_insert BEFORE INSERT on #{@prefix}errors FOR EACH ROW BEGIN #{proc_time} END")
       
-      FC::DB.connect.query(%{
+      FC::DB.query(%{
         CREATE TABLE #{@prefix}copy_rules (
           id int NOT NULL AUTO_INCREMENT,
           copy_storages text NOT NULL DEFAULT '',
@@ -193,7 +218,7 @@ module FC
         ) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci
       })
       
-      FC::DB.connect.query(%{
+      FC::DB.query(%{
         CREATE TABLE #{@prefix}vars (
           name varchar(255) DEFAULT NULL,
           val varchar(255) DEFAULT NULL,
@@ -202,19 +227,41 @@ module FC
           PRIMARY KEY (name)
         ) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci
       })
-      FC::DB.connect.query("CREATE TRIGGER fc_vars_before_insert BEFORE INSERT on #{@prefix}vars FOR EACH ROW BEGIN #{proc_time} END")
-      FC::DB.connect.query("CREATE TRIGGER fc_vars_before_update BEFORE UPDATE on #{@prefix}vars FOR EACH ROW BEGIN #{proc_time} END")
-      FC::DB.connect.query("INSERT INTO #{@prefix}vars SET name='daemon_cycle_time', val='30', descr='time between global daemon checks and storages available checks'")
-      FC::DB.connect.query("INSERT INTO #{@prefix}vars SET name='daemon_global_wait_time', val='120', descr='time between runs global daemon if it does not running'")
-      FC::DB.connect.query("INSERT INTO #{@prefix}vars SET name='daemon_tasks_copy_group_limit', val='1000', descr='select limit for copy tasks'")
-      FC::DB.connect.query("INSERT INTO #{@prefix}vars SET name='daemon_tasks_delete_group_limit', val='10000', descr='select limit for delete tasks'")
-      FC::DB.connect.query("INSERT INTO #{@prefix}vars SET name='daemon_tasks_copy_threads_limit', val='10', descr='copy tasks threads count limit for one storage'")
-      FC::DB.connect.query("INSERT INTO #{@prefix}vars SET name='daemon_tasks_delete_threads_limit', val='10', descr='delete tasks threads count limit for one storage'")
-      FC::DB.connect.query("INSERT INTO #{@prefix}vars SET name='daemon_copy_tasks_per_host_limit', val='10', descr='copy tasks count limit for one host'")
-      FC::DB.connect.query("INSERT INTO #{@prefix}vars SET name='daemon_global_tasks_group_limit', val='1000', descr='select limit for create copy tasks'")
-      FC::DB.connect.query("INSERT INTO #{@prefix}vars SET name='daemon_global_error_items_ttl', val='86400', descr='ttl for items with error status before delete'")
-      FC::DB.connect.query("INSERT INTO #{@prefix}vars SET name='daemon_global_error_items_storages_ttl', val='86400', descr='ttl for items_storages with error status before delete'")
-      FC::DB.connect.query("INSERT INTO #{@prefix}vars SET name='daemon_restart_period', val='86400', descr='time between fc-daemon self restart'")
+      FC::DB.query("CREATE TRIGGER fc_vars_before_insert BEFORE INSERT on #{@prefix}vars FOR EACH ROW BEGIN #{proc_time} END")
+      FC::DB.query("CREATE TRIGGER fc_vars_before_update BEFORE UPDATE on #{@prefix}vars FOR EACH ROW BEGIN #{proc_time} END")
+      FC::DB.query("INSERT INTO #{@prefix}vars SET name='daemon_cycle_time', val='30', descr='time between global daemon checks and storages available checks'")
+      FC::DB.query("INSERT INTO #{@prefix}vars SET name='daemon_global_wait_time', val='120', descr='time between runs global daemon if it does not running'")
+      FC::DB.query("INSERT INTO #{@prefix}vars SET name='daemon_tasks_copy_group_limit', val='1000', descr='select limit for copy tasks'")
+      FC::DB.query("INSERT INTO #{@prefix}vars SET name='daemon_tasks_delete_group_limit', val='10000', descr='select limit for delete tasks'")
+      FC::DB.query("INSERT INTO #{@prefix}vars SET name='daemon_tasks_copy_threads_limit', val='10', descr='copy tasks threads count limit for one storage'")
+      FC::DB.query("INSERT INTO #{@prefix}vars SET name='daemon_tasks_delete_threads_limit', val='10', descr='delete tasks threads count limit for one storage'")
+      FC::DB.query("INSERT INTO #{@prefix}vars SET name='daemon_copy_tasks_per_host_limit', val='10', descr='copy tasks count limit for one host'")
+      FC::DB.query("INSERT INTO #{@prefix}vars SET name='daemon_global_tasks_group_limit', val='1000', descr='select limit for create copy tasks'")
+      FC::DB.query("INSERT INTO #{@prefix}vars SET name='daemon_global_error_items_ttl', val='86400', descr='ttl for items with error status before delete'")
+      FC::DB.query("INSERT INTO #{@prefix}vars SET name='daemon_global_error_items_storages_ttl', val='86400', descr='ttl for items_storages with error status before delete'")
+      FC::DB.query("INSERT INTO #{@prefix}vars SET name='daemon_restart_period', val='86400', descr='time between fc-daemon self restart'")
+      
+      FC::DB.migrations(silent)
+    end
+    
+    def self.version
+      return 1
+    end
+    
+    def self.migrations(silent = false)
+      next_version = FC::DB.query("SELECT val FROM #{FC::DB.prefix}vars WHERE name='db_version'").first['val'].to_i + 1 rescue 1
+      while self.respond_to?("migrate_#{next_version}")
+        puts "migrate to #{next_version}" unless silent
+        self.send("migrate_#{next_version}")
+        FC::DB.query("REPLACE #{FC::DB.prefix}vars SET val=#{next_version}, name='db_version'")
+        next_version += 1
+      end
+    end
+    
+    def self.migrate_1
+      FC::DB.query("ALTER TABLE #{@prefix}storages ADD COLUMN url_weight int NOT NULL DEFAULT 0")
+      FC::DB.query("ALTER TABLE #{@prefix}storages ADD COLUMN write_weight int NOT NULL DEFAULT 0")
+      FC::DB.query("INSERT INTO #{@prefix}vars SET name='daemon_copy_speed_per_host_limit', val='', descr='copy tasks speed limit for hosts, change via fc-manage copy_speed'")
     end
   end
 end

data/lib/fc/item.rb

@@ -67,19 +67,23 @@ module FC
     def make_item_storage(storage, status = 'new')
       # new storage_item?
       item_storage = FC::ItemStorage.where('item_id=? AND storage_name=?', id, storage.name).first
-      item_storage.delete if item_storage
+      if item_storage
+        item_storage.delete 
+        storage.size = storage.size.to_i - size.to_i
+      end
       
       item_storage = FC::ItemStorage.new({:item_id => id, :storage_name => storage.name, :status => status})
       item_storage.save
+      storage.size = storage.size.to_i + size.to_i
       item_storage
     end
     
-    def copy_item_storage(src, storage, item_storage, remove_local = false)
+    def copy_item_storage(src, storage, item_storage, remove_local = false, speed_limit = nil)
       begin
         if src.instance_of?(FC::Storage)
-          src.copy_to_local(name, "#{storage.path}#{name}")
+          src.copy_to_local(name, "#{storage.path}#{name}", speed_limit)
         else
-          storage.copy_path(src, name, remove_local)
+          storage.copy_path(src, name, remove_local, speed_limit)
         end
         md5_on_storage = storage.md5_sum(name)
       rescue Exception => e
@@ -130,7 +134,24 @@ module FC
     def get_available_storages
       r = FC::DB.query("SELECT st.* FROM #{FC::Storage.table_name} as st, #{FC::ItemStorage.table_name} as ist WHERE 
         ist.item_id = #{id} AND ist.status='ready' AND ist.storage_name = st.name")
-      r.map{|data| FC::Storage.create_from_fiels(data)}.select {|storage| storage.up? }
+      r.map{|data| FC::Storage.create_from_fiels(data)}.select {|storage| storage.up? && storage.url_weight.to_i >= 0}
+    end
+    
+    def urls
+      get_available_storages.map{|storage| File.join(storage.url, name)}
+    end
+    
+    def url
+      available_storages = get_available_storages()
+      # sort by random(url_weight) 
+      best_storage = available_storages.map{ |storage| 
+        [storage, Kernel.rand(storage.url_weight.to_i * 100)] 
+      }.sort{ |a, b|
+        a[1] <=> b[1]
+      }.map{|el| el[0]}.last
+      best_storage = available_storages.sample unless best_storage
+      raise "URL find - no avable storage for item #{id}" unless best_storage
+      File.join(best_storage.url, name)
     end
   end
 end

data/lib/fc/policy.rb

@@ -28,36 +28,20 @@ module FC
       @create_storages_cache
     end
     
-    # get available storages for create by size
-    def get_proper_storages_for_create(size, exclude = [])
-      get_create_storages.select do |storage|
-        !exclude.include?(storage.name) && storage.up? && storage.size + size < storage.size_limit
-      end
-    end
-    
     # get available storage for create by size and local item path
     def get_proper_storage_for_create(size, local_path = nil)
-      storages = get_proper_storages_for_create(size)
-      dev = File.stat(local_path).dev if local_path
-      
-      # sort by current_host and free size
-      storages.sort do |a, b|
-        if FC::Storage.curr_host == a.host && FC::Storage.curr_host == b.host
-          if local_path && dev == File.stat(a.path).dev
-            1
-          elsif local_path && dev == File.stat(b.path).dev
-            -1
-          else
-            a.free_rate <=> b.free_rate
-          end
-        elsif FC::Storage.curr_host == a.host
-          1
-        elsif FC::Storage.curr_host == b.host
-          -1
-        else
-          a.free_rate <=> b.free_rate
+      FC::Storage.select_proper_storage_for_create(get_create_storages, size) do |storages|
+        local_storages = storages.select{|storage| FC::Storage.curr_host == storage.host}
+        # find same storage device as local_path device
+        if local_path && !local_storages.empty?
+          dev = File.stat(local_path).dev
+          dev_storage = local_storages.select{|storage| dev == File.stat(storage.path).dev}.first
+          local_storages = [dev_storage] if dev_storage
         end
-      end.last
+        # if no local storages - use all storages
+        local_storages = storages if local_storages.empty?
+        local_storages
+      end
     end
   end
 end

data/lib/fc/storage.rb

@@ -3,7 +3,7 @@ require 'shellwords'
 
 module FC
   class Storage < DbBase
-    set_table :storages, 'name, host, path, url, size, size_limit, check_time, copy_storages'
+    set_table :storages, 'name, host, path, url, size, size_limit, check_time, copy_storages, url_weight, write_weight'
     
     class << self
       attr_accessor :check_time_limit, :storages_cache_time, :get_copy_storages_mutex
@@ -16,6 +16,19 @@ module FC
       @uname || @uname = `uname -n`.chomp
     end
     
+    def self.select_proper_storage_for_create(storages, size, exclude = [])
+      list = storages.select do |storage|
+        !exclude.include?(storage.name) && storage.up? && storage.size + size < storage.size_limit && storage.write_weight.to_i >= 0
+      end
+      list = yield(list) if block_given?
+      # sort by random(free_rate * write_weight)
+      list.map{ |storage| 
+        [storage, Kernel.rand(storage.free_rate * (storage.write_weight.to_i == 0 ? 0.01 : storage.write_weight.to_i) * 1000000000)] 
+      }.sort{ |a, b|
+        a[1] <=> b[1]
+      }.map{|el| el[0]}.last
+    end
+    
     def initialize(params = {})
       path = (params['path'] || params[:path])
       if path && !path.to_s.empty?
@@ -35,7 +48,8 @@ module FC
     end
     
     def free_rate
-      free.to_f / size_limit
+      rate = free.to_f / size_limit
+      rate < 0 ? 0.0 : rate
     end
     
     def get_copy_storages
@@ -63,7 +77,7 @@ module FC
     end
     
     # copy local_path to storage
-    def copy_path(local_path, file_name, try_move = false)
+    def copy_path(local_path, file_name, try_move = false, speed_limit = nil)
       dst_path = "#{self.path}#{file_name}"
 
       cmd = "rm -rf #{dst_path.shellescape}; mkdir -p #{File.dirname(dst_path).shellescape}"
@@ -72,23 +86,25 @@ module FC
       raise r if $?.exitstatus != 0
       
       op = try_move && self.class.curr_host == host && File.stat(local_path).dev == File.stat(File.dirname(dst_path)).dev ? 'mv' : 'cp -r'
+      speed_limit = (speed_limit * 1000).to_i if speed_limit.to_i > 0
       cmd = self.class.curr_host == host ?
         "#{op} #{local_path.shellescape} #{dst_path.shellescape}" :
-        "scp -r -q -oBatchMode=yes -oStrictHostKeyChecking=no #{local_path.shellescape} #{self.host}:\"#{dst_path.shellescape}\""
+        "scp -r -q -oBatchMode=yes -oStrictHostKeyChecking=no #{speed_limit.to_i > 0 ? '-l '+speed_limit.to_s : ''} #{local_path.shellescape} #{self.host}:\"#{dst_path.shellescape}\""
       r = `#{cmd} 2>&1`
       raise r if $?.exitstatus != 0
     end
     
     # copy object to local_path
-    def copy_to_local(file_name, local_path)
+    def copy_to_local(file_name, local_path, speed_limit = nil)
       src_path = "#{self.path}#{file_name}"
       
       r = `rm -rf #{local_path.shellescape}; mkdir -p #{File.dirname(local_path).shellescape} 2>&1`
       raise r if $?.exitstatus != 0
       
+      speed_limit = (speed_limit * 1000).to_i if speed_limit.to_i > 0
       cmd = self.class.curr_host == host ? 
         "cp -r #{src_path.shellescape} #{local_path.shellescape}" : 
-        "scp -r -q -oBatchMode=yes -oStrictHostKeyChecking=no #{self.host}:\"#{src_path.shellescape}\" #{local_path.shellescape}"
+        "scp -r -q -oBatchMode=yes -oStrictHostKeyChecking=no #{speed_limit.to_i > 0 ? '-l '+speed_limit.to_s : ''} #{self.host}:\"#{src_path.shellescape}\" #{local_path.shellescape}"
       r = `#{cmd} 2>&1`
       raise r if $?.exitstatus != 0
     end
@@ -102,6 +118,7 @@ module FC
       r = `#{cmd} 2>&1`
       raise r if $?.exitstatus != 0
       
+      speed_limit = (speed_limit * 1000).to_i if speed_limit.to_i > 0
       cmd = self.class.curr_host == host ? 
         "ls -la #{dst_path.shellescape}" : 
         "ssh -q -oBatchMode=yes -oStrictHostKeyChecking=no #{self.host} \"ls -la #{dst_path.shellescape}\""
@@ -134,9 +151,7 @@ module FC
     
     # get available storage for copy by size
     def get_proper_storage_for_copy(size, exclude = [])
-      get_copy_storages.select do |storage|
-        !exclude.include?(storage.name) && storage.up? && storage.size + size < storage.size_limit
-      end.first
+      FC::Storage.select_proper_storage_for_create(get_copy_storages, size, exclude)
     end
   end
 end

data/lib/fc/var.rb

@@ -35,5 +35,28 @@ module FC
       end
       @all_vars 
     end
+    
+    def self.get_speed_limits
+      limits = {
+        'all' => nil
+      }
+      list = self.get('daemon_copy_speed_per_host_limit', '').to_s
+      limits.merge! Hash[list.split(';;').map{|v| v.split('::')}]
+      limits.each{|host, val| limits[host] = val.to_f > 0 ? val.to_f : nil }
+    end
+    
+    def self.set_speed_limit(host, val)
+      limits = self.get_speed_limits
+      limits[host.to_s] = val.to_f
+      list = limits.map{|h, v| "#{h}::#{v}"}.join(';;')
+      self.set('daemon_copy_speed_per_host_limit', list)
+    end
+    
+    def self.get_current_speed_limit
+      limits = self.get_speed_limits
+      limit = limits[FC::Storage.curr_host]
+      limit = limits['all'] unless limit
+      limit
+    end
   end
 end

data/lib/fc/version.rb

@@ -1,3 +1,3 @@
 module FC
-  VERSION = "0.4.5"
+  VERSION = "0.4.6"
 end

data/lib/manage.rb

@@ -5,3 +5,4 @@ require "manage/show"
 require "manage/copy_rules"
 require "manage/var"
 require "manage/item"
+require "manage/copy_speed"

data/lib/manage/copy_speed.rb

@@ -0,0 +1,74 @@
+# encoding: utf-8
+require 'shellwords'
+
+def copy_speed_list
+  FC::Var.get_speed_limits.each do |name, val|
+    puts name.to_s+(val ? " - limit: #{val}Mbit" : " - unlimit")
+  end
+end
+
+def copy_speed_add
+  hosts = ['all'] + all_hosts
+  puts "Add copy speed limit"
+  begin
+    host = stdin_read_val("Host (default #{FC::Storage.curr_host})", true).strip
+    host = FC::Storage.curr_host if host.empty?
+    puts "Host can be one of: #{hosts.join(', ')}" unless hosts.index(host)
+  end until hosts.index(host)
+  limit = stdin_read_val("Speed limit, Mbit/s (default 0 - unlimit)", true).to_f
+  puts %Q{\nCopy speed limit
+  Host:         #{host}
+  Speed limit:  #{limit > 0 ? limit : 'unlimit'}}
+  s = Readline.readline("Continue? (y/n) ", false).strip.downcase
+  puts ""
+  if s == "y" || s == "yes"
+    begin
+      FC::Var.set_speed_limit(host, limit)
+    rescue Exception => e
+      puts "Error: #{e.message}"
+      exit
+    end
+    puts "ok"
+  else
+    puts "Canceled."
+  end
+end
+
+def copy_speed_change
+  if host = find_host
+    puts "Change copy speed limit for host #{host}"
+    curr_limit = FC::Var.get_speed_limits[host]
+    limit = stdin_read_val("Speed limit, Mbit/s (now #{curr_limit ? curr_limit.to_s+', 0 to unlimit' : 'unlimit'})", true)
+    puts limit.to_f
+    puts limit == ''
+    limit = limit == '' ? curr_limit : limit.to_f
+    puts %Q{\nCopy speed limit
+    Host:         #{host}
+    Speed limit:  #{limit > 0 ? limit : 'unlimit'}}
+    s = Readline.readline("Continue? (y/n) ", false).strip.downcase
+    puts ""
+    if s == "y" || s == "yes"
+      begin
+        FC::Var.set_speed_limit(host, limit)
+      rescue Exception => e
+        puts "Error: #{e.message}"
+        exit
+      end
+      puts "ok"
+    else
+      puts "Canceled."
+    end
+  end
+end
+
+private
+
+def all_hosts
+  FC::Storage.where('1').map(&:host).uniq
+end
+
+def find_host
+  host = ARGV[2].to_s.strip
+  puts "Storage with host #{host} not found." unless (['all'] + all_hosts).index(host)
+  host
+end

data/lib/manage/storages.rb

@@ -24,6 +24,8 @@ def storages_show
   Host:           #{storage.host} 
   Path:           #{storage.path} 
   Url:            #{storage.url}
+  Url weight:     #{storage.url_weight}
+  Write weight    #{storage.write_weight}
   Size:           #{size_to_human storage.size} (#{(storage.size_rate*100).to_i}%)
   Free:           #{size_to_human storage.free} (#{(storage.free_rate*100).to_i}%) 
   Size limit:     #{size_to_human storage.size_limit}
@@ -40,6 +42,8 @@ def storages_add
   name = stdin_read_val('Name')
   path = stdin_read_val('Path')
   url = stdin_read_val('Url')
+  url_weight = stdin_read_val('URL weight', true).to_i
+  write_weight = stdin_read_val('Write weight', true).to_i
   size_limit = human_to_size stdin_read_val('Size limit') {|val| "Size limit not is valid size." unless human_to_size(val)}
   copy_storages = stdin_read_val('Copy storages', true)
   storages = FC::Storage.where.map(&:name)
@@ -47,7 +51,7 @@ def storages_add
   begin
     path = path +'/' unless path[-1] == '/'
     path = '/' + path unless path[0] == '/'
-    storage = FC::Storage.new(:name => name, :host => host, :path => path, :url => url, :size_limit => size_limit, :copy_storages => copy_storages)
+    storage = FC::Storage.new(:name => name, :host => host, :path => path, :url => url, :size_limit => size_limit, :copy_storages => copy_storages, :url_weight => url_weight, :write_weight => write_weight)
     print "Calc current size.. "
     size = storage.file_size('', true)
     puts "ok"
@@ -61,6 +65,8 @@ def storages_add
   Host:         #{host} 
   Path:         #{path} 
   Url:          #{url}
+  URL weight:   #{url_weight}
+  Write weight: #{write_weight}
   Size:         #{size_to_human size} (#{(size.to_f*100 / size_limit).to_i}%)
   Free:         #{size_to_human free} (#{(free.to_f*100 / size_limit).to_i}%)
   Size limit:   #{size_to_human size_limit}
@@ -117,6 +123,8 @@ def storages_change
     host = stdin_read_val("Host (now #{storage.host})", true)
     path = stdin_read_val("Path (now #{storage.path})", true)
     url = stdin_read_val("Url (now #{storage.url})", true)
+    url_weight = stdin_read_val("URL weight (now #{storage.url_weight})", true)
+    write_weight = stdin_read_val("Write weight (now #{storage.write_weight})", true)
     size_limit = stdin_read_val("Size (now #{size_to_human(storage.size_limit)})", true) {|val| "Size limit not is valid size." if !val.empty? && !human_to_size(val)}
     copy_storages = stdin_read_val("Copy storages (now #{storage.copy_storages})", true)
     
@@ -130,6 +138,8 @@ def storages_change
       puts "ok"
     end
     storage.url = url unless url.empty?
+    storage.url_weight = url_weight.to_i unless url_weight.empty?
+    storage.write_weight = write_weight.to_i unless write_weight.empty?
     storage.size_limit = human_to_size(size_limit) unless size_limit.empty?
     storages = FC::Storage.where.map(&:name)
     storage.copy_storages = copy_storages.split(',').select{|s| storages.member?(s.strip)}.join(',').strip unless copy_storages.empty?
@@ -139,6 +149,8 @@ def storages_change
     Host:          #{storage.host} 
     Path:          #{storage.path} 
     Url:           #{storage.url}
+    URL weight:    #{storage.url_weight}
+    Write weight:  #{storage.write_weight}
     Size:          #{size_to_human storage.size} (#{(storage.size_rate*100).to_i}%)
     Free:          #{size_to_human storage.free} (#{(storage.free_rate*100).to_i}%)
     Size limit:    #{size_to_human storage.size_limit}

data/lib/utils.rb

@@ -1,12 +1,17 @@
 def option_parser_init(descriptions, text)
-  options = {}
+  options = {
+    :__keys => {}
+  }
   optparse = OptionParser.new do |opts|
     opts.banner = text
     opts.separator "Options:"
     
     descriptions.each_entry do |key, desc|
       options[key] = desc[:default]
-      opts.on("-#{desc[:short]}", "--#{desc[:full]}#{desc[:no_val] ? '' : '='+desc[:full].upcase}", desc[:text]) {|s| options[key] = s }
+      opts.on("-#{desc[:short]}", "--#{desc[:full]}#{desc[:no_val] ? '' : '='+desc[:full].upcase}", desc[:text]) do |s|
+        options[:__keys][key] = s
+        options[key] = s
+      end
     end
     opts.on_tail("-?", "--help", "Show this message") do
       puts opts
@@ -25,9 +30,11 @@ end
 def size_to_human(size)
   return "0" if size == 0
   units = %w{B KB MB GB TB}
+  minus = size < 0
+  size = -1 * size if minus
   e = (Math.log(size)/Math.log(1024)).floor
   s = "%.2f" % (size.to_f / 1024**e)
-  s.sub(/\.?0*$/, units[e])
+  (minus ? '-' : '')+s.sub(/\.?0*$/, units[e])
 end
 
 def human_to_size(size)

data/test/copy_rule_test.rb

@@ -75,6 +75,15 @@ class CopyRuleTest < Test::Unit::TestCase
     @@storages[1].update_check_time
     assert_equal 'rec2-sda', FC::CopyRule.get_proper_storage_for_copy(:name => 'test1/test', :size => 5).name, 'second storages up, small file'
     assert_equal 'rec1-sda', FC::CopyRule.get_proper_storage_for_copy(:name => 'test1/test', :size => 20).name, 'second storages up, big file'
-    assert_nil FC::CopyRule.get_proper_storage_for_copy(:name => 'test1/test', :size => 1000), 'second storages up, big file'
+    assert_nil FC::CopyRule.get_proper_storage_for_copy(:name => 'test1/test', :size => 1000), 'second storages up, very big file'
+    @@storages[1].write_weight = 100
+    @@storages[1].save
+    @@storages[2].update_check_time
+    assert_equal 'rec2-sda', FC::CopyRule.get_proper_storage_for_copy(:name => 'test1/test', :size => 1).name, 'all storages up, choose by weight'
+    @@storages[1].write_weight = -1
+    @@storages[1].save
+    @@storages[2].write_weight = -1
+    @@storages[2].save
+    assert_equal 'rec1-sda', FC::CopyRule.get_proper_storage_for_copy(:name => 'test1/test', :size => 20).name, 'all storages up, 2 disabled by weight, work second rule'
   end
 end

data/test/helper.rb

@@ -13,5 +13,5 @@ FC::DB.connect_by_config(:username => TEST_USER, :password => TEST_PASSWORD)
 FC::DB.query("DROP DATABASE IF EXISTS #{TEST_DATABASE}")
 FC::DB.query("CREATE DATABASE #{TEST_DATABASE}")
 FC::DB.query("USE #{TEST_DATABASE}")
-FC::DB.init_db
+FC::DB.init_db(true)
 FC::DB.options[:database] = TEST_DATABASE

data/test/item_test.rb

@@ -3,18 +3,19 @@ require 'helper'
 class ItemTest < Test::Unit::TestCase
   class << self
     def startup
-      @@item = FC::Item.new(:name => 'test item', :policy_id => 1, :size => 150)
+      @@item = FC::Item.new(:name => '/test item', :policy_id => 1, :size => 150)
       @@item.save
       
       @@storages = []
-      @@storages << FC::Storage.new(:name => 'rec1-sda', :host => 'rec1')
-      @@storages << FC::Storage.new(:name => 'rec2-sda', :host => 'rec2')
+      @@storages << FC::Storage.new(:name => 'rec1-sda', :host => 'rec1', :url => 'http://rec1/sda/')
+      @@storages << FC::Storage.new(:name => 'rec2-sda', :host => 'rec2', :url => 'http://rec2/sda/')
       @@item_storages = @@storages.map do |storage|
         storage.save
         item_storage = FC::ItemStorage.new(:item_id => @@item.id, :storage_name => storage.name, :status => 'ready')
         item_storage.save
         item_storage
       end
+      @@storages << FC::Storage.new(:name => 'rec3-sda', :host => 'rec3', :url => 'http://rec3/sda/')
     end
     def shutdown
       FC::DB.query("DELETE FROM items_storages")
@@ -29,7 +30,7 @@ class ItemTest < Test::Unit::TestCase
     assert_raise(ArgumentError) { FC::Item.create_from_local '/bla/bla' }
     assert_raise(ArgumentError) { FC::Item.create_from_local '/bla/bla', 'test' }
     assert_raise(RuntimeError) { FC::Item.create_from_local '/bla/bla', 'test', {}}
-    assert_raise(RuntimeError) { FC::Item.create_from_local '/bla/bla/bla', 'test', policy}
+    assert_raise() { FC::Item.create_from_local '/bla/bla/bla', 'test', policy}
   end
   
   should "mark_deleted" do
@@ -42,13 +43,42 @@ class ItemTest < Test::Unit::TestCase
     end
   end
   
+  should "make_item_storage" do
+    storage_size = @@storages[2].size.to_i
+    assert_kind_of FC::ItemStorage, @@item.make_item_storage(@@storages[2])
+    assert_equal storage_size+@@item.size, @@storages[2].size
+  end
+  
   should "get_item_storages" do
     assert_same_elements @@item_storages.map(&:id), @@item.get_item_storages.map(&:id)
   end
   
   should "item get_available_storages" do
+    @@storages.each{|s| s.check_time = 0; s.save}
     @@storages[0].update_check_time
     assert_equal 1, @@item.get_available_storages.count
     assert_equal @@storages[0].name, @@item.get_available_storages.first.name
   end
+  
+  should "item urls" do
+    @@storages.each{|s| s.check_time = 0; s.save}
+    assert_equal 0, @@item.urls.count
+    @@storages.each(&:update_check_time)
+    assert_same_elements ["http://rec1/sda/test item", "http://rec2/sda/test item"], @@item.urls
+  end
+  
+  should "item url by url_weight" do
+    @@storages.each(&:update_check_time)
+    @@storages.each{|s| s.url_weight = -1; s.save}
+    assert_raise(RuntimeError) { @@item.url }
+    
+    @@storages[0].url_weight = 1
+    @@storages[0].save
+    assert_equal "http://rec1/sda/test item", @@item.url
+    
+    @@storages[1].url_weight = 2
+    @@storages[1].save
+    Kernel.stubs(:rand).returns(1)
+    assert_equal "http://rec2/sda/test item", @@item.url
+  end
 end

data/test/policy_test.rb

@@ -64,6 +64,10 @@ class PolicyTest < Test::Unit::TestCase
     assert_equal 'rec2-sdb', @@policy.get_proper_storage_for_create(9, 'test-rec2-sdb').name, 'current host, dev match'
     @@storages[3].check_time = 0;
     @@storages[3].save
+    original_rand = Kernel.method(:rand)
+    def Kernel.rand(a)
+      a
+    end
     assert_equal 'rec2-sdc', @@policy.get_proper_storage_for_create(9, 'test-rec2-sdb').name, 'current host, most free storage'
     FC::Storage.stubs(:curr_host).returns('rec3')
     @@storages[5].check_time = 0;
@@ -72,6 +76,14 @@ class PolicyTest < Test::Unit::TestCase
     FC::Storage.stubs(:curr_host).returns('rec5')
     assert_equal 'rec1-sda', @@policy.get_proper_storage_for_create(9, 'test-rec2-sdb').name, 'not current host, most free storage'
     assert_equal 'rec2-sdc', @@policy.get_proper_storage_for_create(10, 'test-rec2-sdb').name, 'not current host, big file, most free storage with free space'
+    @@storages[4].write_weight = -1;
+    @@storages[4].save
+    assert_equal 'rec3-sdb', @@policy.get_proper_storage_for_create(10, 'test-rec2-sdb').name, 'not current host, big file, most weight storage with free space'
+    @@storages[2].write_weight = 10;
+    @@storages[2].save
+    assert_equal 'rec2-sda', @@policy.get_proper_storage_for_create(10, 'test-rec2-sdb').name, 'not current host, big file, most weight storage with free space'
     File.unstub(:stat)
+    Kernel.send(:remove_method, :rand)
+    Kernel.define_singleton_method(:rand, original_rand)
   end
 end

data/test/storage_test.rb

@@ -65,6 +65,8 @@ class StorageTest < Test::Unit::TestCase
     assert_equal 'rec1-sda', @@storages[2].get_proper_storage_for_copy(5).name, 'first storages up'
     assert_nil @@storages[2].get_proper_storage_for_copy(20), 'first storage full'
     @@storages[1].update_check_time
+    @@storages[0].write_weight = 100
+    @@storages[0].save
     assert_equal 'rec1-sda', @@storages[2].get_proper_storage_for_copy(5).name, 'second storages up, small file'
     assert_equal 'rec2-sda', @@storages[2].get_proper_storage_for_copy(20).name, 'second storages up, big file'
     assert_nil @@storages[2].get_proper_storage_for_copy(1000), 'second storages up, huge file'

metadata

@@ -1,110 +1,97 @@
 --- !ruby/object:Gem::Specification
 name: filecluster
 version: !ruby/object:Gem::Version
-  version: 0.4.5
-  prerelease: 
+  version: 0.4.6
 platform: ruby
 authors:
 - sh
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-02-11 00:00:00.000000000 Z
+date: 2015-04-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mysql2
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: test-unit
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: shoulda-context
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: mocha
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 0.13.3
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 0.13.3
 description: Distributed storage
@@ -117,7 +104,7 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
+- ".gitignore"
 - Gemfile
 - LICENSE
 - README.md
@@ -148,6 +135,7 @@ files:
 - lib/filecluster.rb
 - lib/manage.rb
 - lib/manage/copy_rules.rb
+- lib/manage/copy_speed.rb
 - lib/manage/item.rb
 - lib/manage/policies.rb
 - lib/manage/show.rb
@@ -169,33 +157,26 @@ files:
 - test/version_test.rb
 homepage: ''
 licenses: []
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: -4597744036765809736
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: -4597744036765809736
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.24
+rubygems_version: 2.4.3
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Distributed storage
 test_files:
 - test/base_test.rb