cluster_management 0.7 → 0.7.1

data/Rakefile

@@ -2,7 +2,7 @@ require 'rake_ext'
 
 project(
   name: "cluster_management",
-  version: "0.7",
+  version: "0.7.1",
   summary: "Simple Cluster Management Tools",
 
   author: "Alexey Petrushin",

data/lib/cluster_management/cluster.rb

@@ -1,14 +1,7 @@
-class ClusterManagement::Cluster
-  attr_accessor :config, :logger  
-  attr_reader :boxes
-  
-  def services &b
-    b ? @services.instance_eval(&b) : @services
-  end
-  
+class ClusterManagement::Cluster      
   class Services < BasicObject
     def initialize
-      @h = ::Hash.new do |h, service_name|          
+      @h = ::Hash.new do |h, service_name|        
         h[service_name] = ::ClusterManagement::Service.service_class(service_name).new
       end
     end
@@ -23,32 +16,28 @@ class ClusterManagement::Cluster
         ::Object.send :p, msg
       end
       
-      def method_missing m, *a, &b          
-        super unless a.blank? and b.blank?
+      def method_missing m
         @h[m]
       end
   end
 
   def initialize 
     @services = Services.new
-    
+        
     @boxes = Hash.new do |h, host|
-      box = config.ssh? ? Box.new(host.to_s, config.ssh.to_h) : Box.new(host.to_s)  
+      box = config.ssh ? Box.new(host.to_s, config.ssh) : Box.new(host.to_s)  
       box.open
       h[host] = box
     end
   end
-
-  def configure runtime_dir            
-    config.merge_file! "#{runtime_dir}/config/config.yml"
-    config.set! :config_path, "#{runtime_dir}/config"
-    
-    r = {}
-    config.boxes!.to_h.each do |box, tags|
-      tags.each do |tag|
-        (r[tag.to_sym] ||= []) << box
-      end
-    end      
-    config.set! :tags, r
-  end  
+  
+  attr_reader :boxes
+  
+  def services &b
+    b ? @services.instance_eval(&b) : @services
+  end
+  
+  attr_writer :config, :logger
+  def config; @config || raise("config not defined!") end
+  def logger; @logger || raise("logger not defined!") end
 end

data/lib/cluster_management/config.rb

@@ -1,10 +1,41 @@
-class ClusterManagement::Config < SafeHash
-  def merge_file! file_path
-    raise("config file must have .yml extension (#{file_path})!") unless file_path.end_with? '.yml'
-    data = ::YAML.load_file file_path      
+class ClusterManagement::Config < Hash
+  def load_config! runtime_path    
+    merge! runtime_path: runtime_path, config_path: "#{runtime_path}/config"
+    
+    path = "#{runtime_path}/config/config.yml"
+    raise("config file must have .yml extension (#{path})!") unless path.end_with? '.yml'
+
+    data = ::YAML.load_file path
     if data
-      data.must_be.a ::Hash        
-      self.merge! data, override: true
+      data.must_be.a ::Hash
+      data.each{|k, v| self[k.to_sym] = v}
+    end
+
+    # converting :handy_scheme to :scheme
+    if include? :handy_scheme
+      raise "You can't use both :handy_scheme and :scheme!" if include?(:scheme)
+      self.scheme = {}
+      handy_scheme.each do |box, tags|
+        tags.each do |tag|
+          (self.scheme[tag.to_sym] ||= []) << box
+        end
+      end
+    end
+  end
+  
+  def self.require_attr *attrs
+    attrs.each do |m|
+      define_method(m){self[m] || raise("key :#{m} not defined!")}
     end
   end
+  require_attr :scheme, :config_path, :runtime_path
+  
+  protected
+    def method_missing m, *args
+      if m =~ /=$/
+        self[m[0..-2].to_sym] = args.first
+      else
+        self[m]
+      end
+    end
 end

data/lib/cluster_management/gems.rb

@@ -3,5 +3,6 @@ gem 'tilt'
 if respond_to? :fake_gem
   fake_gem 'ruby_ext'
   fake_gem 'vos'
-  fake_gem 'class_loader'
+  fake_gem 'vfs'
+  fake_gem 'class_loader'  
 end

data/lib/cluster_management/integration/vos.rb

@@ -1,18 +1,6 @@
 class Vos::Box
   include Vos::Helpers::Ubuntu
   
-  # alias_method :mark_without_service!, :mark!
-  # def mark! key
-  #   key = key.respond_to(:marker) || key
-  #   mark_without_service! key
-  # end
-  #   
-  # alias_method :has_mark_without_service?, :has_mark?
-  # def has_mark? key
-  #   key = key.respond_to(:marker) || key
-  #   has_mark_without_service? key
-  # end
-    
   def apply_once key, &block
     unless has_mark? key
       block.call self
@@ -20,43 +8,4 @@ class Vos::Box
     end
   end      
   
-end
-
-# module Vos
-#   class ServicesHelper < BasicObject
-#     def initialize box, class_namespace
-#       @box, @class_namespace = box, class_namespace
-#     end
-#     
-#     class ServiceCallback < BasicObject
-#       def initialize box, class_namespace, class_name
-#         @box, @class_namespace, @class_name = box, class_namespace, class_name
-#       end
-#       
-#       protected
-#         def method_missing m, *a, &b
-#           klass = "::#{@class_namespace.to_s.camelize}::#{@class_name.to_s.camelize}".constantize
-#           klass.new(@box).send m, *a, &b
-#         end
-#     end
-#     
-#     protected
-#       def method_missing class_name
-#         ServiceCallback.new(@box, @class_namespace, class_name)
-#       end
-#   end
-#   
-#   # class Box
-#   #   def self.define_service_namespace class_namespace
-#   #     define_method class_namespace do
-#   #       ServicesHelper.new self, class_namespace
-#   #     end
-#   #   end
-#   #   define_service_namespace :services
-#   #   define_service_namespace :projects
-#   #   
-#   #   def already_required_services
-#   #     @already_required_services ||= Set.new
-#   #   end
-#   # end
-# end
+end

data/lib/cluster_management/service.rb

@@ -8,8 +8,9 @@ class ClusterManagement::Service
       end
     end
     
-    def tag tag = nil
+    def tag tag = nil      
       if tag
+        tag.must_be.a Symbol
         @tag = tag
       else
         @tag || raise("service :#{service_name} not tagged!")
@@ -26,7 +27,7 @@ class ClusterManagement::Service
     end
     cache_method_with_params :service_class
     
-    def service_name; name.split('::').last.underscore end
+    def service_name; name.split('::').last.underscore.to_sym end
     cache_method_with_params :service_name
   end
   
@@ -38,46 +39,18 @@ class ClusterManagement::Service
     def service_name; self.class.service_name end
   
     def apply_once key, &block
-      boxes{|box| box.apply_once self.class.marker(key), &block}
+      boxes.each{|box| box.apply_once self.class.marker(key), &block}
     end
     
-    def boxes &b
-      if b
-        boxes.each &b
-      else
-        unless @boxes
-          hosts = config.tags!["#{self.class.tag}", nil] || []
-          @boxes = hosts.collect{|host| cluster.boxes[host]}
-        end
-        @boxes
+    def boxes
+      @boxes ||= begin
+        hosts = config.scheme[self.class.tag] || []
+        @boxes = hosts.collect{|host| cluster.boxes[host]}
       end
     end
     
-    def single_box
+    def box
       boxes.size.must_be == 1
       boxes.first
     end
-    
-    # def require options
-    #   # if args.size == 1 and args.first.is_a?(Hash)
-    #   #   services = args.first
-    #   # elsif args.size == 2 and args.first.is_a?(Array)
-    #   #   services = {}
-    #   #   args.first.each{|klass| services[klass] = args.last}
-    #   # else
-    #   #   raise 'invalid arguments'
-    #   # end
-    #   
-    #   options.each do |service_name, method|
-    #     key = "#{service_name}.#{method}"
-    #     unless box.already_required_services.include? key
-    #       klass.new(box).send method if klass.method_defined? method
-    #       box.already_required_services << key
-    #     end
-    #   end
-    # end      
-    # 
-    # def already_required_services
-    #   
-    # end
 end

data/lib/cluster_management/support/exception.rb

@@ -1,4 +1,4 @@
-warn 'stack trace filtering enabled'
+# warn 'stack trace filtering enabled'
 
 Exception.metaclass_eval do
   attr_accessor :filters
@@ -26,7 +26,7 @@ Exception.filters = [
   "/class_loader",
   "/micon"
 ]
-# Exception.filters = []
+Exception.filters = []
 
 Exception.class_eval do
   alias_method :set_backtrace_without_filter, :set_backtrace

data/lib/cluster_management.rb

@@ -3,15 +3,11 @@ require 'vos'
 require 'yaml'
 require 'tilt'
 require 'class_loader'
-# require 'micon'
-# require 'micon/rad'
 
 module ClusterManagement
 end
 
-# 
-# Classes
-# 
+# Libraries
 %w(
   support/exception
   config
@@ -23,17 +19,17 @@ end
 ).each{|f| require "cluster_management/#{f}"}
 
 
-# 
 # Cluster
-# 
 CLUSTER = ClusterManagement::Cluster.new
-def cluster; ::CLUSTER end
+def cluster; CLUSTER end
 
 
-# 
 # Config & Logger
-# 
 cluster.logger = ClusterManagement::CustomLogger.new STDOUT
 cluster.logger.formatter = -> severity, datetime, progname, msg {msg}
 
-cluster.config = ClusterManagement::Config.new
+cluster.config = ClusterManagement::Config.new
+
+# Handy shortcut
+Service = ClusterManagement::Service
+

data/readme.md

@@ -1,141 +1,178 @@
-# Simple cluster management tools
+# Simple Cluster Management Tool
 
 It may be **usefull if Your claster has about 1-10 boxes**, and tools like Chef, Puppet, Capistrano are too complex and proprietary for your needs.
-**It's extremely easy**, there are only 3 methods. 
+**It's very easy**, there are only a 3 concept - Box, Cluster and Service.
 
-You probably already familiar with Rake and have it in Your project, and because ClusterManagement is just a small Rake 
-addon it should be easy to add and get started with it.
+Usage:
 
-It's ssh-agnostic and has no extra dependencies. You can use whatever ssh-tool you like (even pure Net::SSH / Net::SFTP), 
-samples below are done by using [Virtual Operating System][vos] and [Virtual File System][vfs] tools.
+ - package installation, dependencies, versioning
+ - process management, start/stop services
+ - deplyment
 
-## BoxTask Management
+It's designed to be used with [Virtual File System][vfs], [Virtual Operation System][vos] and Rake, but it's not required, You can use other tools also.
 
-Define your packages, they are just rake tasks, so you probably know how to work with them:
+## Core Concepts
 
-    desc 'ruby 1.9.2'
-    package ruby: :system_tools do        
-      apply_once do
-        installation_dir = '/usr/local/ruby'
-        ruby_name = "ruby-1.9.2-p136"
+- Box - a PC with remote access.
+- Service - some abstract thing (a package, running process, app, ...) that operates on 1..n boxes. It can perform install/update/start/stop/.. operations and request other services to perform things it needs.
+- Deployment Scheme - defines how services are distributed among boxes.
 
-        box.tmp do |tmp|
-          tmp.bash "wget ftp://ftp.ruby-lang.org//pub/ruby/1.9/#{ruby_name}.tar.gz"
-          tmp.bash "tar -xvzf #{ruby_name}.tar.gz"
+## Deployment Scheme
 
-          src_dir = tmp[ruby_name]
-          src_dir.bash "./configure --prefix=#{installation_dir}"
-          src_dir.bash 'make && make install'
-        end
+Let's suppose that we want to deploy our App on a cluster of 3 boxes using the following scheme. **Tags** are used to define connections (N to M, althouth in example below it's 1 to 1) between **Boxes** and **Services**.
 
-        box.home('.gemrc').write! "gem: --no-ri --no-rdoc\n"
+![Deployment Scheme][deployment_scheme]
 
-        bindir = "#{installation_dir}/bin"
-        unless box.env_file.content =~ /PATH.*#{bindir}/
-          box.env_file.append %(\nexport PATH="$PATH:#{bindir}"\n)
-          box.reload_env
-        end
-      end    
-      verify{box.bash('ruby -v') =~ /ruby 1.9.2/}
-    end
-      
-Or you can use a little more explicit notation with custom :applied? logic (:apply_once is a shortcut for :applied? & :after_applying):
-
-    package :ruby do
-      applied?{box.has_mark? :ruby}
-      apply do
-        ...
-      end
-      after_applying{box.mark :ruby}
-    end
-    
-Let's define another package:
-    
-    package rails: :ruby, version: 3 do
-      apply_once do
-        box.bash 'gem install rails'
-      end
+Deployment scheme defined via box tags (in config) and service tags, see below.
+
+## Boxes
+
+Boxes are defined in config:
+
+```yaml
+handy_scheme:
+  'web1.app.com': ['web']
+  'web2.app.com': ['web']
+  'db.app.com': ['db']
+```
+
+## Services
+
+Dependencies are defined by calling another services, it's easy to use and understand and allows high flexibility in configuration.
+
+And, **it's 'smart'**, in sample below the App::deploy method is smart ennought to figure out that it needs the Ruby and MySQL Services and it will call for them to apply before itself.
+
+You can specify that the package should be applied only once (see :apply_once), and use versioning (see :version) - change the version and it will be reapplied.
+
+It supports iterative development and can figure out what services are missing and needs to be applied, You don't have to write all the config at once, do it by small steps, adding one package after another. 
+
+Below are our Services:
+
+```ruby
+class Services::Ruby < Service
+  tag :web
+  version 4
+  
+  def install
+    # it will be called only once, it will be called next time only if You change the version
+    apply_once :install do |box|            
+      logger.info "installing :#{service_name}"
+      box.fake_bash "apt-get install ruby"
     end
-    
-It's understands dependencies, so the :rails package will apply :ruby before applying itself. 
-
-It checks if the package already has been applied to box, so you can evolve your configuration and apply it multiple times, 
-it will apply only missing packages (or drop the applied? clause and it will be applied every run). It allows you
-to use **iterative development**, you don't need to write all the config at once, do it by small steps, adding one package after another. 
-
-You can also use versioning to update already installed packages - if You change version it will be reapplied next run.
-And by the way, the box.mark ... is just an example check, you can use anything there.
-    
-And, last step - define (I intentionally leave implementation of this method to You, it's very specific to Your environment) 
-to what machines it should be applied:
-
-    module ClusterManagement
-      def self.boxes
-        unless @boxes    
-          host = ENV['host'] || raise(":host not defined!")
-          box = Vos::Box.new host: host, ssh: config.ssh!.to_h
-          box.open
-
-          @boxes = [box]
-        end
-        @boxes
-      end
+  end
+end
+
+class Services::Thin < Service
+  tag :web
+  
+  def restart
+    logger.info "restarting :#{service_name}"
+    boxes.each{|box| box.fake_bash 'thin restart'}
+  end
+end
+
+class Services::MySql < Service
+  tag :db
+  def started
+    logger.info "ensuring mysql is running"
+    box.fake_bash 'mysql start' unless box.fake_bash('ps -A') =~ /mysql/
+  end
+end
+
+class Services::App < Service
+  tag :web
+
+  def install      
+    services.ruby.install        
+    apply_once :install do |box| 
+      logger.info "installing :#{service_name}"
+      box.fake_bash "cd #{config.app_path} && git clone app"
     end
-    
-Now, you can press the enter:
-
-    $ rake os:rails host=myapp.com
-    
-and box_task will do all the job of installing and configuring your cluster boxes, and prints you something like that 
-(it's a sample output of some of my own box, you can see config details here [my_cluster][my_cluster]):
-    
-    $ rake app_server host=universal.xxx.com
-    applying 'basic:os:5' to '<Box: universal.xxx.com>'
-    applying 'basic:apt' to '<Box: universal.xxx.com>'
-    applying 'basic:system_tools' to '<Box: universal.xxx.com>'
-    applying 'basic:ruby' to '<Box: universal.xxx.com>'
-      building ... done
-      updating path ... done
-    applying 'basic:git' to '<Box: universal.xxx.com>'
-    applying 'basic:security:6' to '<Box: universal.xxx.com>'
-    applying 'basic:manual_management:2' to '<Box: universal.xxx.com>'
-    applying 'app_server:fake_gem:2' to '<Box: universal.xxx.com>'
-    applying 'app_server:custom_ruby:3' to '<Box: universal.xxx.com>'
-    
-You can also use standard Rake -T command to see docs (it's also from my config, details are here [my_cluster][my_cluster]):
-
-    $ rake -T
-    rake app_server               # app server
-    rake app_server:custom_ruby   # custom ruby (with encoding globally set to unicode and enabled fake_gem hack)
-    rake app_server:fake_gem      # fake_gem
-    rake basic                    # Box with basic packages installed
-    rake basic:apt                # apt
-    rake basic:git                # git
-    rake basic:manual_management  # Makes box handy for manual management
-    rake basic:os                 # Checks OS version and add some very basic stuff
-    rake basic:ruby               # ruby
-    rake basic:security           # security
-    rake basic:system_tools       # System tools, mainly for build support
-    rake db                       # db
-    rake db:mongodb               # MongoDB
-
-## Service Management
-
-[add details here]
-    
-## Deployment
-
-[add more details here]
-    
-**You can use it also for deployment**, exactly the same way, configure it the way you like, it's just rake 
-tasks.
-
-# Temporarry stuff, don't bother to read it
-
-- small
-- uses well known tools (rake and anytingh ssh-enabled)
-- support iterative development
+  end
+
+  def update
+    install        
+    logger.info "updating :#{service_name}"
+    boxes.each{|box| box.fake_bash "cd #{config.app_path} && git pull app"}
+  end
+
+  def deploy    
+    update
+    logger.info "deploying :#{service_name}"  
+    services.my_sql.started
+    services.thin.restart
+  end    
+end
+```
+
+## Rake
+
+```ruby
+desc 'deploy to cluster'
+task :deploy do
+  cluster.services.app.deploy
+end
+```
+
+Note: You don't have install services before deployment, the **App::deploy will resolve all dependencies automatically and fully configure all boxes from clean state** - it will install packages, ensure all needed services are running and only then will start deployment.
+
+Now, type:
+
+```bash
+$ rake deploy
+```
+
+You'll se something like this:
+
+```
+installing :ruby
+   => bash: 'apt-get install ruby'
+installing :app
+   => bash: 'cd /tmp/cm_example_app && git clone app'
+updating :app
+   => bash: 'cd /tmp/cm_example_app && git pull app'
+deploying :app
+ensuring mysql is running
+   => bash: 'ps -A'
+   => bash: 'mysql start'
+restarting :thin
+   => bash: 'thin restart'
+```
+
+Deploy one more time, notice now there's no installation of Ruby and App:
+
+```
+updating :app
+   => bash: 'cd /tmp/cm_example_app && git pull app'
+deploying :app
+ensuring mysql is running
+   => bash: 'ps -A'
+   => bash: 'mysql start'
+restarting :thin
+   => bash: 'thin restart'
+```
+
+## Installation
+
+```bash
+$ gem install cluster_management
+```
+
+## Examples
+
+Go to [example][:example] folder, there are full example, type 'rake deploy' and look at the output.
+
+For simplicity it uses the 'localhost' instead of 3 remote boxes and 'fake_bash' that just prints command to console (because we don't want to actually alter our localhost).
+But You can easily define actual remote PCs in config and replace 'fake_bash' with 'bash' and see it in the real action.
+
+You can also see 'real' configuration I use to manage the [http://ruby-lang.info](http://ruby-lang.info) site, [my_cluster][my_cluster].
+
+## Bugs, Suggestion, Discussions
+
+Please feel free to submit bugs and proposals to the issue tab above, or contact me directly.
 
 [my_cluster]: http://github.com/alexeypetrushin/my_cluster/tree/master/lib/packages
 [vos]: http://github.com/alexeypetrushin/vos
-[vfs]: http://github.com/alexeypetrushin/vfs
+[vfs]: http://github.com/alexeypetrushin/vfs
+[deployment_scheme]: https://github.com/alexeypetrushin/cluster_management/raw/master/readme/deployment_scheme.png
+[example]: https://github.com/alexeypetrushin/cluster_management/tree/master/example

data/spec/cluster_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe "Cluster" do
+  before do
+    @cluster = Cluster.new
+    @cluster.config = Config.new
+  end
+  
+  it "should return service by it's name" do
+    service_class = mock
+    service_class.should_receive(:new).and_return('mongo_db')
+    Service.stub!(:service_class).and_return(service_class)
+    
+    @cluster.services[:mongo_db].should == 'mongo_db'
+    @cluster.services.mongo_db.should == 'mongo_db'
+  end
+  
+  it "should return box by it's name" do
+    box = mock
+    box.should_receive(:open)
+    Box.stub!(:new).and_return(box)
+        
+    @cluster.boxes['app.com'].should == box
+  end
+end

data/spec/config_spec/app/config/config.yml

@@ -0,0 +1,7 @@
+handy_scheme:
+  'web1.app.com': ['app', 'ruby']
+  'web2.app.com': ['app', 'ruby']
+  'db.app.com': ['db']
+
+nginx:
+  port: 80

data/spec/config_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe "Config" do
+  it "should load and parse config file" do
+    config = Config.new
+    config.load_config! "#{spec_dir}/app"
+    
+    {      
+      config_path:  "#{spec_dir}/app/config",
+      runtime_path: "#{spec_dir}/app",
+      
+      scheme: {
+        app:  ['web1.app.com', 'web2.app.com'],
+        ruby: ['web1.app.com', 'web2.app.com'],
+        db:   ['db.app.com']
+      },
+      
+      nginx: {'port' => 80}
+    }.each do |k, v|
+      config[k].should == v
+    end
+  end
+end

data/spec/dependency_spec.rb

@@ -0,0 +1,67 @@
+require 'spec_helper'
+
+describe 'Dependency' do
+  before :all do    
+    module Services; end
+    
+    class ServiceStub < Service
+      def apply_once key, &b
+        boxes.each &b
+      end
+      
+      def boxes
+        [ServiceStub.box]
+      end
+      
+      class << self
+        attr_accessor :box
+      end
+    end        
+    
+    class BoxStub < Array
+      alias_method :bash, :push
+    end
+  end
+  after(:all){remove_constants :Services, :ServiceStub, :BoxStub}
+  
+  it "dependency resolving" do        
+    class Services::Ruby < ServiceStub
+      def install
+        apply_once(:install){|box| box.bash 'install ruby'}
+      end
+    end
+    
+    class Services::Server < ServiceStub
+      def restart
+        boxes.each{|box| box.bash 'restart server'}
+      end
+    end
+      
+    class Services::App < ServiceStub
+      def install          
+        services.ruby.install        
+        apply_once(:install){|box| box.bash 'install app'}
+      end
+      
+      def update
+        install        
+        boxes.each{|box| box.bash 'update app'}
+      end
+      
+      def deploy
+        update
+        services.server.restart
+      end
+    end
+   
+    ServiceStub.box = BoxStub.new
+    
+    Services::App.new.deploy
+    ServiceStub.box.should == [
+      'install ruby',
+      'install app',
+      'update app',
+      'restart server'
+    ]
+  end
+end

data/spec/service_spec.rb

@@ -0,0 +1,80 @@
+require 'spec_helper'
+
+describe "Service" do
+  before{module Services; end}
+  after{remove_constants :Services}
+  
+  it "should return service class by service name" do
+    class Services::App; end
+    Service.service_class(:app).should == Services::App    
+  end
+  
+  it "version, tag, marker" do
+    class Services::Db < Service
+      service_name.should == :db
+    end
+    
+    -> {Services::Db.tag}.should raise_error(/not tagged/)
+    Services::Db.version.should == 1
+      
+    class Services::Db
+      tag :db
+      version 2
+      
+      tag.should == :db
+      version.should == 2
+      marker.should == 'db:2'
+    end         
+  end
+
+  it "shold return only boxes this service should be deployed" do
+    cluster = Cluster.new
+    cluster.stub!(:boxes).and_return(
+      'web1.app.com' => :web1, 'web2.app.com' => :web2, 'db.app.com' => :db
+    )
+    cluster.config = Config.new    
+    cluster.config.scheme = {
+      app:  ['web1.app.com', 'web2.app.com'],
+      db:   ['db.app.com']
+    }
+    
+    class Services::App < Service
+      tag :app
+    end
+    app = Services::App.new
+    app.stub!(:cluster).and_return(cluster)
+    
+    app.send(:boxes).sort.should == [:web1, :web2]
+  end
+  
+  it "single box" do
+    class Services::App < Service; end
+    app = Services::App.new
+    app.stub!(:boxes).and_return([:a, :b])
+    -> {app.send(:box)}.should raise_error(AssertionError)
+    app.stub!(:boxes).and_return([:a])
+    app.send(:box).should == :a
+  end
+  
+  it "should be applied only once if required" do    
+    box = mock
+    box.should_receive :apply_once do |key, &b| 
+      key.should == 'app:2:install'
+      b.call box
+    end
+    box.should_receive(:install_app)
+    
+    class Services::App < Service
+      version 2
+      
+      def install
+        apply_once :install do |box|
+          box.install_app
+        end
+      end
+    end
+    app = Services::App.new
+    app.stub!(:boxes).and_return([box])
+    app.install
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,4 @@
+require 'rspec_ext'
+require 'cluster_management'
+
+Cluster, Config = ClusterManagement::Cluster, ClusterManagement::Config

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cluster_management
 version: !ruby/object:Gem::Version
-  version: '0.7'
+  version: 0.7.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,12 +9,12 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-06-24 00:00:00.000000000 +04:00
+date: 2011-07-02 00:00:00.000000000 +04:00
 default_executable: 
 dependencies:
 - !ruby/object:Gem::Dependency
   name: tilt
-  requirement: &2738130 !ruby/object:Gem::Requirement
+  requirement: &3013040 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -22,10 +22,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *2738130
+  version_requirements: *3013040
 - !ruby/object:Gem::Dependency
   name: ruby_ext
-  requirement: &2737850 !ruby/object:Gem::Requirement
+  requirement: &3012690 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -33,10 +33,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *2737850
+  version_requirements: *3012690
 - !ruby/object:Gem::Dependency
   name: vos
-  requirement: &2737650 !ruby/object:Gem::Requirement
+  requirement: &3012450 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -44,10 +44,21 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *2737650
+  version_requirements: *3012450
+- !ruby/object:Gem::Dependency
+  name: vfs
+  requirement: &3012180 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *3012180
 - !ruby/object:Gem::Dependency
   name: class_loader
-  requirement: &2737450 !ruby/object:Gem::Requirement
+  requirement: &3011950 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -55,7 +66,7 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *2737450
+  version_requirements: *3011950
 description: 
 email: 
 executables: []
@@ -73,6 +84,12 @@ files:
 - lib/cluster_management/service.rb
 - lib/cluster_management/support/exception.rb
 - lib/cluster_management.rb
+- spec/cluster_spec.rb
+- spec/config_spec/app/config/config.yml
+- spec/config_spec.rb
+- spec/dependency_spec.rb
+- spec/service_spec.rb
+- spec/spec_helper.rb
 has_rdoc: true
 homepage: http://github.com/alexeypetrushin/cluster_management
 licenses: []