cluster_management 0.0.1 → 0.5.1

data/Rakefile

@@ -2,7 +2,7 @@ require 'rake_ext'
 
 project(
   name: "cluster_management",
-  version: "0.0.1",
+  version: "0.5.1",
   summary: "Simple cluster management tools",
 
   author: "Alexey Petrushin",

data/lib/cluster_management/cluster_management.rb

@@ -0,0 +1,39 @@
+module ClusterManagement
+  class << self
+    # 
+    # use :integration attribute to provide integration with your tool (use integration/rsh as a sample).
+    # 
+    attr_writer :integration
+    def integration
+      unless @integration
+        not_supported = -> *args {raise "you must provide your own implementation!"}
+        @integration = {
+          has_mark?: not_supported,
+          mark: not_supported
+        }
+      end
+      @integration
+    end
+    
+    
+    #
+    # you must override this method to provide your own implementation
+    #
+    attr_writer :boxes
+    def boxes
+      unless @boxes
+        warn('you must override :boxes method to provide your own behaviour')
+        return []
+      end
+      @boxes
+    end
+    
+    
+    # 
+    # Rake integration
+    # 
+    def rake_task *args, &block
+      task *args, &block
+    end        
+  end  
+end

data/lib/cluster_management/integration/vos.rb

@@ -0,0 +1,4 @@
+ClusterManagement.integration = {
+  has_mark?: -> box, mark {box.has_mark? mark},
+  mark: -> box, mark {box.mark mark}
+}

data/lib/cluster_management/package.rb

@@ -1,39 +1,75 @@
-module Ros
+module ClusterManagement
   class Package < Hash
     class Dsl
-      attr_reader :package
+      attr_reader :package, :box
 
-      def initialize package
-        @package = package
+      def initialize package, box
+        @package, @box = package, box
       end
 
-      def version version; package.version = version end    
+      def version; package.version end    
+        
       def applied? &b; package.applied = b end
       def apply &b; package.apply = b end    
       def verify &b; package.verify = b end
       def after_applying &b; package.after_applying = b end    
+      
+      def apply_once &b      
+        mark = package.version ? "#{package.name}:#{package.version}" : package.name.to_s
+        applied?{ClusterManagement.integration[:has_mark?].call box, mark}
+        apply &b
+        after_applying{ClusterManagement.integration[:mark].call box, mark}
+      end
     end
     
     attr_accessor :applied, :apply, :verify, :after_applying, :name, :version
     
-    def initialize name
-      @name = name
-    end
-    
-    def configure_with &b
-      dsl = Dsl.new self
-      b.call dsl
+    def initialize name, version
+      @name, @version = name, version
     end
     
-    def apply_to box
-      package_applied = applied && applied.call(box)
+    def configure box, &b
+      dsl = Dsl.new self, box
+      dsl.instance_eval &b
+
+      if applied
+        package_applied = applied.call box
+        # ensure_boolean! package_applied, :applied?
+      else
+        package_applied = false
+      end
+      
       if apply and !package_applied
-        print "applying '#{name}#{version}' to '#{box}'\n"              
+        ClusterManagement.logger.info %(applying '#{name}#{version ? ":#{version}" : ''}' to '#{box}'\n)
         apply.call box
       end
-      raise "invalid '#{name}' package for '#{box}'!" if verify and !verify.call(box)
+      
+      if verify
+        verified = verify.call box
+        # ensure_boolean! verified, 'verify'
+        raise "invalid '#{name}' package for '#{box}'!" unless verified
+      end
       after_applying && after_applying.call(box)
-      # print "done\n" if apply and !package_applied              
+      # print "done\n" if apply and !package_applied
+    end
+    
+    protected
+      def ensure_boolean! value, method
+        unless value.eql?(true) or value.eql?(false)
+          raise "invalid return value in '#{name}.#{method}' (only true/false allowed)!"
+        end
+      end
+  end  
+end
+
+def package name_or_options, version = nil, &block
+  version ||= name_or_options.delete :version if name_or_options.is_a? Hash
+  ClusterManagement.rake_task name_or_options do |task, *args|
+    if block
+      ClusterManagement.boxes.each do |box|
+        package = ClusterManagement::Package.new task.name, version
+        package.configure box, &block
+      end
     end
   end  
 end

data/lib/cluster_management/support.rb

@@ -0,0 +1,17 @@
+require 'logger'
+
+module ClusterManagement
+  class << self
+    # 
+    # Logger
+    # 
+    attr_writer :logger
+    def logger
+      unless @logger
+        @logger = Logger.new STDOUT
+        @logger.formatter = -> severity, datetime, progname, msg {msg}
+      end
+      @logger      
+    end
+  end  
+end

data/lib/cluster_management.rb

@@ -1,12 +1,7 @@
 %w(
-  rake
+  support
   package
+  cluster_management  
 ).each{|f| require "cluster_management/#{f}"}
 
-#
-# you must override this method to provide your own implementation
-#
-def boxes
-  warn 'you must override :boxes method to provide your own behaviour'
-  []
-end
+require 'cluster_management/integration/vos' unless $cluster_management_dont_include_integration

data/readme.md

@@ -3,37 +3,90 @@
 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.
 
+## Package management
+
 Define your packages, they are just rake tasks, so you probably know how to work with them:
 
-    namespace :os do
-      package :ruby do
-        applied?{|box| box.has_mark? :ruby}
-        apply do |box| 
-          box.bash 'apt-get install ruby'
-          box.mark :ruby
-        end
+    package :ruby do
+      applied?{box.has_mark? :ruby}
+      apply do
+        box.bash 'apt-get install ruby'          
       end
+      after_applying{box.mark :ruby}
+    end
+      
+or you can use a little shorter notation (it's equivalent to the previous):
 
-      package :rails => :ruby do
-        applied?{|box| box.has_mark? :rails}
-        apply do |box| 
-          box.bash 'gem install rails'
-          box.mark :rails
-        end
+    package rails: :ruby, version: 3 do
+      apply_once do
+        box.bash 'gem install rails'
       end
     end
     
-Define to what it should be applied:
+And it's understands dependencies, so the :rails package will apply :ruby before applying itself. 
+It also support iterative development, so you don't need to write all the config at once, do it by small steps, adding one package after another. 
+And you can use versioning to update already installed packages - if you change version of some package it will be reapplied next run.
+    
+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:
 
-    def each_box &b
-      host = ENV['host'] || raise(":host not defined!")
-      box = Rsh::Box.new host: host, ssh: {user: 'root', password: 'secret'}
-      b.call box
+    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
     
-Run it:
+Now, you can press the enter:
+
+    $ rake os:rails host=myapp.com
+    
+and packager 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
+
+## Runtime services
 
-    $ rake os:rails host=webapp.com
+[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. And by the way, the *box.mark ...* is just an example check, you can use anything there.
@@ -41,6 +94,10 @@ tasks. And by the way, the *box.mark ...* is just an example check, you can use
 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).
 
+# Temporarry stuff, don't bother to read it
+
 - small
 - uses well known tools (rake and anytingh ssh-enabled)
-- support iterative development
+- support iterative development
+
+[my_cluster]: https://github.com/alexeypetrushin/my_cluster/tree/master/lib/packages

data/spec/package_spec.rb

@@ -0,0 +1,136 @@
+require 'spec_helper'
+require 'cluster_management/package'
+
+describe 'Package' do
+  before :each do
+    ClusterManagement.box = :box
+  end
+  
+  it 'should allow empty declaration' do
+    package :tools
+    ClusterManagement.last_task.should_not be_nil
+    
+    ClusterManagement.last_task = nil
+    package(:tools){}
+    ClusterManagement.last_task.should_not be_nil
+  end
+  
+  it "basic" do
+    check = mock()
+    check.should_receive(:applied?).ordered.and_return(false)
+    check.should_receive(:apply).ordered
+    check.should_receive(:verify).ordered.and_return(true)
+    check.should_receive(:after_applying).ordered
+    
+    the_package, the_box = nil, nil
+    package :tools, 1 do
+      package.is_a?(ClusterManagement::Package).should == true
+      version.should == 1
+      box.should == :box
+      
+      
+      applied?{check.applied?(box)}
+      apply{check.apply(box)}
+      verify{check.verify(box)}
+      after_applying{check.after_applying(box)}
+    end
+  end
+  
+  it "should not reapply package but always verify it" do
+    check = mock()
+    check.should_not_receive(:apply)
+    check.should_receive(:verify).and_return(true)
+    
+    package :tools do
+      applied?{true}
+      apply{check.apply}
+      verify{check.verify}
+    end
+  end
+  
+  it "should verify packages" do
+    -> {
+      package :tools do
+        verify{false}
+      end
+    }.should raise_error(/invalid.*tools/)
+  end
+  
+  it "should apply to all boxes" do
+    boxes = [:a, :b]
+    ClusterManagement.stub(:boxes).and_return(boxes)
+    
+    check = []
+    package :tools do
+      apply{check << box}
+    end
+    check.should == boxes
+  end
+  
+  it 'should support version attribute' do
+    package :tools, 2 do
+      version.should == 2
+    end
+    
+    package tools: :os, version: 2 do
+      version.should == 2
+    end
+  end
+  
+  describe "apply_once" do
+    def build_box_for key, has_mark
+      box = mock()    
+      box.should_receive(:has_mark?).ordered.with(key).and_return(has_mark)
+      box.should_receive(:mark).ordered.with(key)
+      ClusterManagement.box = box
+      box
+    end
+    
+    it "should apply if not applied" do    
+      box = build_box_for('tools', false)
+    
+      check = mock()
+      check.should_receive(:apply_once).with(box)
+    
+      package :tools do
+        apply_once{check.apply_once(box)}
+      end
+    end
+    
+    it "should not apply if applied" do    
+      box = build_box_for('tools', true)
+    
+      check = mock()
+      check.should_not_receive(:apply_once)
+    
+      package :tools do
+        apply_once{check.apply_once}
+      end
+    end
+    
+    it "should support versioning" do
+      box = build_box_for('tools:2', false)
+    
+      check = mock()
+      check.should_receive(:apply_once)
+    
+      package :tools, 2 do
+        apply_once{check.apply_once}
+      end
+    end
+  end
+end
+
+
+# def version version; package.version = version end    
+# def applied? &b; package.applied = b end
+# def apply &b; package.apply = b end    
+# def verify &b; package.verify = b end
+# def after_applying &b; package.after_applying = b end    
+# 
+# def apply_once &b      
+#   mark = package.version ? "#{package.name}:#{package.version}" : package.name
+#   applied?{INTEGRATION[:has_mark?].call box, mark}
+#   apply &b
+#   after_applying{INTEGRATION[:mark].call box, mark}
+# end

data/spec/spec_helper.rb

@@ -0,0 +1,67 @@
+require 'rspec_ext'
+
+require 'cluster_management/support'
+require 'cluster_management/cluster_management'
+
+
+# 
+# Boxes stub
+# 
+module ClusterManagement
+  class << self
+    attr_accessor :box
+    
+    def boxes
+      [box]
+    end
+  end
+end
+
+
+# 
+# Integration stub
+# 
+ClusterManagement.integration = {
+  has_mark?: -> box, mark {box.has_mark? mark},
+  mark: -> box, mark {box.mark mark}
+}
+
+
+# 
+# Task stub
+# 
+module ClusterManagement  
+  class Task
+    attr_accessor :name
+    def initialize name
+      @name = name
+    end
+  end
+  
+  class << self
+    attr_accessor :last_task
+  
+    def rake_task name_or_options, &block
+      name = if name_or_options.is_a? Hash
+        name_or_options.first.first
+      else
+        name_or_options
+      end
+      task = Task.new name      
+      block.call task if block
+      self.last_task = task
+    end
+  end
+end
+
+
+# 
+# Logger stub
+# 
+module ClusterManagement
+  class << self
+    def logger
+      @logger ||= Logger.new nil
+    end
+  end
+end

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 0
+  - 5
   - 1
-  version: 0.0.1
+  version: 0.5.1
 platform: ruby
 authors: 
 - Alexey Petrushin
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-02-01 00:00:00 +03:00
+date: 2011-02-09 00:00:00 +03:00
 default_executable: 
 dependencies: []
 
@@ -29,9 +29,13 @@ extra_rdoc_files: []
 files: 
 - Rakefile
 - readme.md
+- lib/cluster_management/cluster_management.rb
+- lib/cluster_management/integration/vos.rb
 - lib/cluster_management/package.rb
-- lib/cluster_management/rake.rb
+- lib/cluster_management/support.rb
 - lib/cluster_management.rb
+- spec/package_spec.rb
+- spec/spec_helper.rb
 has_rdoc: true
 homepage: http://github.com/alexeypetrushin/cluster_management
 licenses: []

data/lib/cluster_management/rake.rb

@@ -1,11 +0,0 @@
-def package *a, &b
-  task *a do |task, *args|
-    if b
-      boxes.each do |box|
-        package = Ros::Package.new task.name
-        package.configure_with &b
-        package.apply_to box
-      end    
-    end
-  end  
-end